@voltro/data-transfer 0.80.0 → 0.82.0

package/THIRD-PARTY-NOTICES.md

@@ -10789,7 +10789,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## undici@8.10.0
+## undici@8.11.2
 
 License: MIT
 

package/dist/index.d.ts

@@ -1218,6 +1218,49 @@ export declare interface MaskInput {
 /** Apply a resolved plan to one row. */
 export declare const maskRow: (row: Row, table: string, actions: Readonly<Record<string, MaskAction>>, seed: string, columnTypes?: Readonly<Record<string, string>>) => Row;
 
+/**
+ * The statements around the import, each one batch, all run on `master`.
+ * `carry` runs after the import: the target's own rows of each environment-local
+ * table replace whatever the artefact brought, matched by column name so an
+ * older artefact with fewer columns still takes them. `swap` puts the copy in
+ * place and drops the replaced database; `undoSwap` puts the old one back if the
+ * swap stops half-way.
+ */
+export declare const mssqlReplaceStatements: (step: Pick<MssqlReplaceStep, "live" | "scratch" | "carry">) => {
+    prepare: string[];
+    carry: string[];
+    swap: string[];
+    undoSwap: string[];
+    cleanup: string[];
+};
+
+/**
+ * The mssql restore. `sqlpackage /Action:Import` accepts only a new or EMPTY
+ * database (SQL71659), so it cannot load over the live one the way `pg_restore
+ * --clean` does. It imports into a scratch database beside it, carries the
+ * TARGET's environment-local rows into that copy (what `EXCLUDED_FROM_DUMP`
+ * achieves on the other dialects: the marker and the transfer history describe
+ * this database, not the source's), then swaps the names. The live database is
+ * untouched until the swap, so a failed import leaves it exactly as it was.
+ */
+export declare interface MssqlReplaceStep {
+    readonly kind: 'mssql-replace';
+    readonly load: Extract<NativeStep, {
+        kind: 'spawn';
+    }>;
+    /** The server, as a connection to `master` — where the swap runs. */
+    readonly server: NativeConn;
+    readonly live: string;
+    readonly scratch: string;
+    readonly carry: ReadonlyArray<string>;
+}
+
+/** The database an mssql restore imports into before the swap. UNIQUE per run:
+ *  after the swap the live database keeps the scratch name's data FILES, so a
+ *  fixed name collides with them on the next restore (`Msg 5170 … already
+ *  exists`). Leftovers of a killed run share the prefix and are dropped first. */
+export declare const mssqlScratchName: (live: string, run?: string) => string;
+
 export declare interface NativeConn {
     /** Full connection URL (preferred for postgres — the tool consumes it
      *  directly). Parsed to flags for mysql. */
@@ -1231,6 +1274,10 @@ export declare interface NativeConn {
     readonly filename?: string;
 }
 
+/** Runs statements for a step that needs SQL rather than a vendor tool. The
+ *  caller owns the driver; this package does not. */
+export declare type NativeSql = (conn: NativeConn, statements: ReadonlyArray<string>) => Effect.Effect<void, unknown>;
+
 /** One executable step: spawn a tool (optionally piping a file to stdin, or its
  *  stdout to a file), or a pure file copy (sqlite). */
 export declare type NativeStep = {
@@ -1247,7 +1294,7 @@ export declare type NativeStep = {
     readonly kind: 'copy';
     readonly from: string;
     readonly to: string;
-};
+} | MssqlReplaceStep;
 
 /** A native backup/restore tool failed — missing binary, non-zero exit, or an
  *  unsupported dialect. `stderr` carries the tool's own diagnostics. INTERNAL —
@@ -1565,9 +1612,10 @@ export declare const runExport: (opts: ExportOptions) => Effect.Effect<Manifest,
 
 export declare const runImport: (opts: ImportOptions) => Effect.Effect<ImportOutcome, ImportError>;
 
-/** Execute a {@link NativeStep} — spawn the tool (wiring stdin/stdout files) or
- *  copy the file. Maps a missing binary / non-zero exit to {@link NativeToolError}. */
-export declare const runNativeStep: (step: NativeStep) => Effect.Effect<void, NativeToolError>;
+/** Execute a {@link NativeStep} — spawn the tool (wiring stdin/stdout files),
+ *  copy the file, or run the mssql import-and-swap through `sql`. Maps a missing
+ *  binary / non-zero exit to {@link NativeToolError}. */
+export declare const runNativeStep: (step: NativeStep, sql?: NativeSql) => Effect.Effect<void, NativeToolError>;
 
 /**
  * Default rows per savepoint. 200 puts the happy-path overhead at one percent