@deterministic-code/migraters 0.0.4 → 0.0.6

package/rust/src/migrater.rs

@@ -2,9 +2,8 @@ use std::fs;
 use std::path::PathBuf;
 use std::time::Instant;
 
-use crate::abstractions::SqlDialect;
+use crate::abstractions::IDatasourceProvider;
 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,
@@ -48,35 +47,37 @@ pub trait IMigrater: Send + Sync {
 }
 
 pub struct Migrater {
-    dialect: &'static dyn SqlDialect,
+    provider: &'static dyn IDatasourceProvider,
 }
 
 impl Migrater {
-    pub fn new(dialect: &'static dyn SqlDialect) -> Self {
-        Self { dialect }
+    pub fn new(provider: &'static dyn IDatasourceProvider) -> Self {
+        Self { provider }
     }
 }
 
 impl IMigrater for Migrater {
     fn name(&self) -> &'static str {
-        self.dialect.name()
+        self.provider.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?;
+        self.provider.prepare_setup(args.connection)?;
+        self.provider
+            .setup(args.connection)
+            .await
+            .map_err(|err| err.to_string())?;
         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?;
+        let mut applied = self
+            .provider
+            .applied(args.connection)
+            .await
+            .map_err(|err| err.to_string())?;
         assert_no_checksum_drift(&files, &applied)?;
         let mut names = Vec::new();
         loop {
@@ -89,40 +90,45 @@ impl IMigrater for Migrater {
             };
             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 log_id = self
+                .provider
+                .log(args.connection, None, &name, "up", None, 0, None)
+                .await
+                .map_err(|err| err.to_string())?;
             let started = Instant::now();
-            match pool
-                .apply_statements(
-                    self.dialect,
-                    &sql,
-                    self.dialect.insert_applied_sql(),
-                    &name,
-                    Some(&sum),
-                )
+            match self
+                .provider
+                .migrate_up(args.connection, &name, &sql, &sum)
                 .await
             {
                 Ok(()) => {
-                    let _ = pool
-                        .update_log(
-                            self.dialect,
-                            log_id,
-                            "success",
+                    let _ = self
+                        .provider
+                        .log(
+                            args.connection,
+                            Some(log_id),
+                            &name,
+                            "up",
+                            Some("success"),
                             started.elapsed().as_millis() as i64,
                             None,
                         )
                         .await;
                 }
                 Err(e) => {
-                    let _ = pool
-                        .update_log(
-                            self.dialect,
-                            log_id,
-                            "error",
+                    let _ = self
+                        .provider
+                        .log(
+                            args.connection,
+                            Some(log_id),
+                            &name,
+                            "up",
+                            Some("error"),
                             started.elapsed().as_millis() as i64,
                             Some(&e.to_string()),
                         )
                         .await;
-                    return Err(e);
+                    return Err(e.to_string().into());
                 }
             }
             applied.insert(name.clone(), Some(sum));
@@ -134,11 +140,12 @@ impl IMigrater for Migrater {
     }
 
     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?;
+        let applied = self
+            .provider
+            .applied(args.connection)
+            .await
+            .map_err(|err| err.to_string())?;
         if applied.is_empty() {
             return Ok(None);
         }
@@ -154,40 +161,45 @@ impl IMigrater for Migrater {
         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 log_id = self
+            .provider
+            .log(args.connection, None, &name, "down", None, 0, None)
+            .await
+            .map_err(|err| err.to_string())?;
         let started = Instant::now();
-        match pool
-            .apply_statements(
-                self.dialect,
-                &sql,
-                self.dialect.delete_applied_sql(),
-                &name,
-                None,
-            )
+        match self
+            .provider
+            .migrate_down(args.connection, &name, &sql)
             .await
         {
             Ok(()) => {
-                let _ = pool
-                    .update_log(
-                        self.dialect,
-                        log_id,
-                        "success",
+                let _ = self
+                    .provider
+                    .log(
+                        args.connection,
+                        Some(log_id),
+                        &name,
+                        "down",
+                        Some("success"),
                         started.elapsed().as_millis() as i64,
                         None,
                     )
                     .await;
             }
             Err(e) => {
-                let _ = pool
-                    .update_log(
-                        self.dialect,
-                        log_id,
-                        "error",
+                let _ = self
+                    .provider
+                    .log(
+                        args.connection,
+                        Some(log_id),
+                        &name,
+                        "down",
+                        Some("error"),
                         started.elapsed().as_millis() as i64,
                         Some(&e.to_string()),
                     )
                     .await;
-                return Err(e);
+                return Err(e.to_string().into());
             }
         }
         Ok(Some(name))

package/rust/src/migraters_config.rs

@@ -0,0 +1,90 @@
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+pub const FILE_NAME: &str = ".migraters.yaml";
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ProviderEntry {
+    pub name: String,
+    pub location: String,
+}
+
+pub fn enabled_providers() -> Vec<ProviderEntry> {
+    match find_path(&env::current_dir().unwrap_or_else(|_| PathBuf::from("."))) {
+        Some(path) => match fs::read_to_string(path) {
+            Ok(raw) => parse_providers(&raw),
+            Err(_) => Vec::new(),
+        },
+        None => Vec::new(),
+    }
+}
+
+pub fn enabled_dialects() -> Vec<String> {
+    enabled_providers().into_iter().map(|p| p.name).collect()
+}
+
+pub fn find_path(start: &Path) -> Option<PathBuf> {
+    let mut dir = start.to_path_buf();
+    loop {
+        let candidate = dir.join(FILE_NAME);
+        if candidate.is_file() {
+            return Some(candidate);
+        }
+        if !dir.pop() {
+            return None;
+        }
+    }
+}
+
+pub fn parse_providers(raw: &str) -> Vec<ProviderEntry> {
+    let mut entries = Vec::new();
+    let mut in_providers = false;
+    let mut name: Option<String> = None;
+    for line in raw.lines() {
+        if !in_providers {
+            if line.trim() == "providers:" {
+                in_providers = true;
+            }
+            continue;
+        }
+        let item = line.trim();
+        if let Some(rest) = item.strip_prefix("- name:") {
+            name = Some(rest.trim().to_string());
+            continue;
+        }
+        if let Some(rest) = item.strip_prefix("location:") {
+            if let Some(n) = name.take() {
+                let location = rest.trim().to_string();
+                if !n.is_empty() && !location.is_empty() {
+                    entries.push(ProviderEntry { name: n, location });
+                }
+            }
+            continue;
+        }
+        if item.is_empty() || item.starts_with("- ") {
+            continue;
+        }
+        break;
+    }
+    entries
+}
+
+#[cfg(test)]
+mod tests {
+    use super::parse_providers;
+
+    #[test]
+    fn reads_block_list() {
+        let names = parse_providers(
+            "language: rust\nproviders:\n  - name: sqlite\n    location: providers/sqlite\n  - name: postgres\n    location: providers/postgres\nbinDir: rust/target/debug\n",
+        );
+        assert_eq!(
+            names.iter().map(|p| p.name.as_str()).collect::<Vec<_>>(),
+            ["sqlite", "postgres"]
+        );
+        assert!(
+            parse_providers("language: rust\nproviders: []\nbinDir: rust/target/debug\n").is_empty()
+        );
+    }
+}

package/typescript/bundle.yaml

@@ -23,7 +23,7 @@ languages:
     dialects:
       sqlite:
         files:
-          - typescript/dialects/sqlite/**
+          - typescript/providers/sqlite/**
           - shared/templates/sql/sqlite/**
         apk: sqlite
         packages:
@@ -31,27 +31,27 @@ languages:
             installScripts: true
       postgres:
         files:
-          - typescript/dialects/postgres/**
+          - typescript/providers/postgres/**
           - shared/templates/sql/postgres/**
         apk: postgresql-client
         packages:
           - name: pg
       mysql:
         files:
-          - typescript/dialects/mysql/**
+          - typescript/providers/mysql/**
           - shared/templates/sql/mysql/**
         apk: mysql-client
         packages:
           - name: mysql2
       sqlserver:
         files:
-          - typescript/dialects/sqlserver/**
+          - typescript/providers/sqlserver/**
           - shared/templates/sql/sqlserver/**
         packages:
           - name: mssql
       oracle:
         files:
-          - typescript/dialects/oracle/**
+          - typescript/providers/oracle/**
           - shared/templates/sql/oracle/**
         packages:
           - name: oracledb
@@ -104,26 +104,26 @@ languages:
     dialects:
       sqlite:
         files:
-          - rust/dialects/sqlite/**
+          - rust/providers/sqlite/**
           - shared/templates/sql/sqlite/**
         apk: sqlite
       postgres:
         files:
-          - rust/dialects/postgres/**
+          - rust/providers/postgres/**
           - shared/templates/sql/postgres/**
         apk: postgresql-client
       mysql:
         files:
-          - rust/dialects/mysql/**
+          - rust/providers/mysql/**
           - shared/templates/sql/mysql/**
         apk: mysql-client
       sqlserver:
         files:
-          - rust/dialects/sqlserver/**
+          - rust/providers/sqlserver/**
           - shared/templates/sql/sqlserver/**
       oracle:
         files:
-          - rust/dialects/oracle/**
+          - rust/providers/oracle/**
           - shared/templates/sql/oracle/**
     commands:
       setup: migrate-setup --provider {{provider}}
@@ -183,7 +183,7 @@ languages:
     dialects:
       sqlite:
         files:
-          - csharp/Dialects/Sqlite/**
+          - csharp/Providers/Sqlite/**
           - shared/templates/sql/sqlite/**
         apk: sqlite
         packages:
@@ -191,7 +191,7 @@ languages:
             version: "9.0.0"
       postgres:
         files:
-          - csharp/Dialects/Postgres/**
+          - csharp/Providers/Postgres/**
           - shared/templates/sql/postgres/**
         apk: postgresql-client
         packages:
@@ -199,7 +199,7 @@ languages:
             version: "9.0.2"
       mysql:
         files:
-          - csharp/Dialects/Mysql/**
+          - csharp/Providers/Mysql/**
           - shared/templates/sql/mysql/**
         apk: mysql-client
         packages:
@@ -207,14 +207,14 @@ languages:
             version: "2.4.0"
       sqlserver:
         files:
-          - csharp/Dialects/SqlServer/**
+          - csharp/Providers/SqlServer/**
           - shared/templates/sql/sqlserver/**
         packages:
           - name: Microsoft.Data.SqlClient
             version: "6.0.2"
       oracle:
         files:
-          - csharp/Dialects/Oracle/**
+          - csharp/Providers/Oracle/**
           - shared/templates/sql/oracle/**
         packages:
           - name: Oracle.ManagedDataAccess.Core

package/typescript/package.json

@@ -20,16 +20,18 @@
   "files": [
     "dist",
     "src",
-    "dialects",
+    "providers",
     "cli.yaml",
+    "driver.yaml",
     "bundle.yaml",
     "tsconfig.build.json"
   ],
   "scripts": {
-    "build": "rm -rf dist.tmp && tsc -p tsconfig.build.json --outDir dist.tmp && cp -R ../shared/templates dist.tmp/templates && cp ../cli.yaml dist.tmp/cli.yaml && rm -rf dist && mv dist.tmp dist",
+    "build": "rm -rf dist.tmp && tsc -p tsconfig.build.json --outDir dist.tmp && cp -R ../shared/templates dist.tmp/templates && cp ../cli.yaml dist.tmp/cli.yaml && cp ../driver.yaml dist.tmp/driver.yaml && rm -rf dist && mv dist.tmp dist",
     "typecheck": "tsc -p tsconfig.src.json --noEmit",
-    "test": "npm run build && node ../orchestrator/dist/migrate-init.js --language typescript --all && vitest run --coverage",
-    "test:coverage": "vitest run --coverage",
+    "test": "node ../orchestrator/attach-sqlite.js typescript && vitest run --config vitest.unit.config.ts",
+    "integration": "npm run build && node ../orchestrator/dist/migrate-init.js --language typescript --all && vitest run --config vitest.integration.config.ts --coverage",
+    "test:coverage": "vitest run --config vitest.integration.config.ts --coverage",
     "generate:help": "node --experimental-strip-types src/generate-help.ts",
     "format": "prettier --write ."
   },

package/typescript/providers/mysql/src/index.ts

@@ -0,0 +1,5 @@
+import { MysqlProvider } from './mysql-provider.ts';
+
+export const createProvider = (): MysqlProvider => new MysqlProvider();
+export const provider = createProvider;
+export { MysqlProvider, applyMysqlDdlViaTextProtocol } from './mysql-provider.ts';

package/typescript/{dialects/mysql/src/mysql-dialect.test.ts → providers/mysql/src/mysql-provider.test.ts}

@@ -34,11 +34,11 @@ vi.mock('mysql2/promise', () => ({
   createConnection: mysql.createConnection,
 }));
 
-import { applyMysqlDdlViaTextProtocol, MysqlDialect } from './mysql-dialect.ts';
+import { applyMysqlDdlViaTextProtocol, MysqlProvider } from './mysql-provider.ts';
 
-const dialect = new MysqlDialect();
+const dialect = new MysqlProvider();
 
-describe('MysqlDialect', () => {
+describe('MysqlProvider', () => {
   afterEach(() => {
     mysql.state.failRollback = false;
     mysql.state.ended = false;
@@ -96,4 +96,14 @@ describe('MysqlDialect', () => {
     await client.close();
     expect(mysql.state.ended).toBe(true);
   });
+
+  it('runs setup, applied, migrate, and log through the sql helper', async () => {
+    const url = 'mysql://localhost/db';
+    await dialect.setup(url);
+    expect(await dialect.applied(url)).toBeInstanceOf(Map);
+    await dialect.migrateUp(url, 'a', 'SELECT 1', 'sum');
+    await dialect.migrateDown(url, 'a', 'SELECT 1');
+    await dialect.log(url, null, 'a', 'up', null, 0, null);
+    await dialect.log(url, 1, 'a', 'up', 'ok', 1, null);
+  });
 });

package/typescript/{dialects/mysql/src/mysql-dialect.ts → providers/mysql/src/mysql-provider.ts}

@@ -1,7 +1,8 @@
+import type { IDatasourceProvider, ProviderLogId } from '../../../src/abstractions/datasource-provider.ts';
 import type { MigrationClient, MigrationRow } from '../../../src/migration-client.ts';
 import { applyMysqlDdlViaTextProtocol } from '../../../src/infrastructure/mysql-text-protocol.ts';
 import { readSqlTemplate } from '../../../src/infrastructure/sql-templates.ts';
-import { SqlDialectBase } from '../../../src/abstractions/sql-dialect-base.ts';
+import { sqlRun } from '../../sql/sql-run.ts';
 
 export { applyMysqlDdlViaTextProtocol };
 
@@ -10,7 +11,7 @@ const [migratesDdl, migrateLogsDdl] = await Promise.all([
   readSqlTemplate('mysql', 'migrate_logs'),
 ]);
 
-export class MysqlDialect extends SqlDialectBase {
+export class MysqlProvider implements IDatasourceProvider {
   readonly name = 'mysql' as const;
   readonly connectionEnvironmentVariables = ['MYSQL_URL', 'DATABASE_URL'] as const;
   readonly migratesDdl = migratesDdl;
@@ -20,6 +21,24 @@ export class MysqlDialect extends SqlDialectBase {
     return `\`${ident}\``;
   }
 
+  nowExpr(): string {
+    return 'CURRENT_TIMESTAMP';
+  }
+
+  limitClause(n: number): string {
+    return `LIMIT ${n}`;
+  }
+
+  translatePlaceholders(sql: string): string {
+    return sql;
+  }
+
+  async prerequisiteError(_connection: string): Promise<string | null> {
+    return null;
+  }
+
+  async prepareSetup(_connection: string): Promise<void> {}
+
   async createDatabaseIfMissing(connection: string): Promise<void> {
     const url = new URL(connection);
     const name = url.pathname.replace(/^\//, '');
@@ -72,4 +91,32 @@ export class MysqlDialect extends SqlDialectBase {
       },
     };
   }
+
+  setup(connection: string): Promise<void> {
+    return sqlRun.setup(this, connection);
+  }
+
+  applied(connection: string): Promise<Map<string, string | null>> {
+    return sqlRun.applied(this, connection);
+  }
+
+  migrateUp(connection: string, name: string, body: string, checksum: string): Promise<void> {
+    return sqlRun.migrateUp(this, connection, name, body, checksum);
+  }
+
+  migrateDown(connection: string, name: string, body: string): Promise<void> {
+    return sqlRun.migrateDown(this, connection, name, body);
+  }
+
+  log(
+    connection: string,
+    id: ProviderLogId | null,
+    name: string,
+    direction: string,
+    status: string | null,
+    durationMs: number,
+    error: string | null,
+  ): Promise<ProviderLogId> {
+    return sqlRun.log(this, connection, id, name, direction, status, durationMs, error);
+  }
 }

package/typescript/providers/oracle/src/index.ts

@@ -0,0 +1,5 @@
+import { OracleProvider } from './oracle-provider.ts';
+
+export const createProvider = (): OracleProvider => new OracleProvider();
+export const provider = createProvider;
+export { OracleProvider, parseOracleConnection } from './oracle-provider.ts';

package/typescript/{dialects/oracle/src/oracle-dialect.test.ts → providers/oracle/src/oracle-provider.test.ts}

@@ -38,9 +38,9 @@ vi.mock('oracledb', () => ({
   },
 }));
 
-import { OracleDialect, parseOracleConnection } from './oracle-dialect.ts';
+import { OracleProvider, parseOracleConnection } from './oracle-provider.ts';
 
-const dialect = new OracleDialect();
+const dialect = new OracleProvider();
 
 describe('parseOracleConnection', () => {
   it('accepts a config object or user/password@connectString', () => {
@@ -57,7 +57,7 @@ describe('parseOracleConnection', () => {
   });
 });
 
-describe('OracleDialect', () => {
+describe('OracleProvider', () => {
   afterEach(() => {
     oracle.state.failRollback = false;
     oracle.state.closed = false;
@@ -78,6 +78,7 @@ describe('OracleDialect', () => {
     expect(dialect.migrateLogsDdl).toMatch(/migrate_logs/i);
     expect(await dialect.prerequisiteError('u/p@c')).toBeNull();
     await dialect.prepareSetup('u/p@c');
+    await dialect.createDatabaseIfMissing('u/p@c');
   });
 
   it('createClient parses the DSN, lowercases row keys, and commits or rolls back', async () => {
@@ -115,4 +116,14 @@ describe('OracleDialect', () => {
     await client.close();
     expect(oracle.state.closed).toBe(true);
   });
+
+  it('runs setup, applied, migrate, and log through the sql helper', async () => {
+    const url = 'scott/tiger@localhost/orcl';
+    await dialect.setup(url);
+    expect(await dialect.applied(url)).toBeInstanceOf(Map);
+    await dialect.migrateUp(url, 'a', 'SELECT 1', 'sum');
+    await dialect.migrateDown(url, 'a', 'SELECT 1');
+    await dialect.log(url, null, 'a', 'up', null, 0, null);
+    await dialect.log(url, 1, 'a', 'up', 'ok', 1, null);
+  });
 });