@voltro/database 0.40.0 → 0.42.0

package/dist/sql.d.ts

@@ -22,6 +22,16 @@ declare interface AggregateColumn<TResult = number | Date | null> {
     readonly _result?: TResult;
 }
 
+/** One condition under which a failed DDL statement means "already done". */
+export declare interface AlreadySatisfied {
+    /** Why this is safe to ignore. Read by a human, not by code. */
+    readonly why: string;
+    /** Driver errnos (mysql family). */
+    readonly errno?: ReadonlyArray<number>;
+    /** Substrings of the driver message (sqlite, which has no errno for these). */
+    readonly messageIncludes?: ReadonlyArray<string>;
+}
+
 declare interface AndPredicate {
     readonly and: ReadonlyArray<Predicate>;
 }
@@ -185,6 +195,19 @@ export declare interface ApplyPlanCtx {
      * ignored); an applier-side re-plan would compare against a different set and
      * report drift that isn't there. A caller that cannot re-plan cannot prove it
      * applied anything.
+     *
+     * **USE THE `sql` THIS HANDS YOU.** It is the connection the apply ran on, and
+     * that is the point: the convergence proof has to observe the session that
+     * made the change. A re-plan that opens its OWN connection is asking a
+     * different session whether the DDL landed, and the answer is not guaranteed
+     * to be yes yet.
+     *
+     * Measured on turso, where a pooled connection serves a `PRAGMA table_info`
+     * from before the `ALTER`: the column was added, the apply succeeded, and the
+     * self-opened re-plan proposed the same `add-column` again — so `applyPlan`
+     * refused to record a fingerprint and told the operator their perfectly good
+     * migration was a framework bug. `voltro db apply` did exactly that for two
+     * releases while `voltro dev`'s boot diff, which uses this parameter, did not.
      */
     readonly replan: (sql: SqlClient.SqlClient) => Effect.Effect<MigrationPlan, SqlError_2, SqlClient.SqlClient>;
 }
@@ -1087,19 +1110,21 @@ declare interface EagerLoadSpec {
 
 export declare const emitAddIndexMysql: (op: Extract<MigrationOperation, {
     kind: "add-index";
-}>, declared: ReadonlyArray<TableLike>) => string;
+}>, declared: ReadonlyArray<TableLike>, engine?: MysqlEngine) => string;
 
 export declare const emitCreateTableMysql: (op: Extract<MigrationOperation, {
     kind: "create-table";
-}>) => ReadonlyArray<string>;
+}>, engine?: MysqlEngine) => ReadonlyArray<string>;
 
 export declare const emitDropColumnDdl: (op: Extract<MigrationOperation, {
     kind: "drop-column";
-}>, q: typeof quote) => string;
+}>, q: typeof quote, 
+/** postgres + mssql accept the conditional form; sqlite does not. */
+conditional?: boolean) => string;
 
 export declare const emitDropColumnDdlMysql: (op: Extract<MigrationOperation, {
     kind: "drop-column";
-}>) => string;
+}>, engine?: MysqlEngine) => string;
 
 /**
  * Bootstrap DDL for framework-managed tables — `CREATE TABLE IF NOT EXISTS`, and
@@ -1178,6 +1203,14 @@ cdcChannel?: string) => string;
 
 declare type EmptyMerge = unknown;
 
+/**
+ * MariaDB stamps itself into the version string — `11.8.8-MariaDB`,
+ * `10.11.2-MariaDB-1:10.11.2+maria~ubu2204`. MySQL never does. The check is
+ * deliberately on VERSION() rather than `@@version_comment`, which some builds
+ * leave generic.
+ */
+export declare const engineFromVersion: (version: string) => MysqlEngine;
+
 /**
  * `EXISTS (SELECT 1 FROM ... WHERE ...)` / `NOT EXISTS (...)`.
  * Mirrors `SubqueryInPredicate` but doesn't bind to a specific
@@ -1453,6 +1486,8 @@ export declare interface IndexSnapshot {
 
 export declare const introspectSchema: (sql: SqlClient.SqlClient) => Effect.Effect<SchemaSnapshot, SqlError_2>;
 
+export declare const isAlreadySatisfied: (err: unknown, rules: ReadonlyArray<AlreadySatisfied>) => boolean;
+
 /** Type-guard for the discovery walker. */
 export declare const isFileMigration: (value: unknown) => value is FileMigration;
 
@@ -1743,6 +1778,9 @@ declare interface MixinIndex {
     readonly kindOptions?: IndexKindOptions;
 }
 
+/** Which engine a `mysql`-dialect connection is actually talking to. */
+export declare type MysqlEngine = 'mysql' | 'mariadb';
+
 /**
  * How long a prefix a MySQL/MariaDB index key may take on this column.
  *
@@ -2497,6 +2535,8 @@ export declare const renderColumnPg: (col: ColumnSnapshot) => string;
  */
 export declare const resolveMigrationLockSchema: (scope?: MigrationLockScope) => string | undefined;
 
+export declare const resolveMysqlEngine: (sql: SqlClient.SqlClient) => Effect.Effect<MysqlEngine, SqlError_2>;
+
 declare type RetryDecision = 'retry' | 'noRetry';
 
 /**