feat: query builder integration for typed data transforms

queryOperations on SqlControlStaticContributions for extension function
support. createBuilders<Contract>() for typed dataTransform callbacks.
SQL lowered at verify time via postgres adapter. Journey test fixes:
migration-new reads storage.storageHash correctly, resume-after-failure
tests use unique constraint violation scenario.

Author: saevarb

test/integration/test/cli-journeys/migration-apply-edge-cases.e2e.test.ts

@@ -72,14 +72,14 @@ withTempDir(({ createTempDir }) => {
     const db = useDevDatabase();
 
     it(
-      'resumes from last successful migration after empty-table precheck failure',
+      'resumes from last successful migration after unique constraint violation',
       async () => {
         const ctx: JourneyContext = setupJourney({
           connectionString: db.connectionString,
           createTempDir,
         });
 
-        // Plan and apply initial migration (creates user table)
+        // Plan and apply initial migration (creates user table with id + email)
         const emit0 = await runContractEmit(ctx);
         expect(emit0.exitCode, 'emit base').toBe(0);
         const plan0 = await runMigrationPlan(ctx, ['--name', 'initial']);
@@ -92,24 +92,22 @@ withTempDir(({ createTempDir }) => {
         );
         expect(firstResult.migrationsApplied, 'applied 1').toBe(1);
 
-        // Insert data so a NOT NULL column addition will fail
+        // Insert rows with duplicate emails
         await sql(
           db.connectionString,
-          `INSERT INTO "user" (id, email) VALUES (1, 'user@example.com')`,
+          `INSERT INTO "user" (id, email) VALUES (1, 'dup@example.com'), (2, 'dup@example.com')`,
         );
 
-        // Plan a migration that adds a non-nullable column (will fail on existing rows)
-        swapContract(ctx, 'contract-additive-required');
+        // Plan migration that adds a unique constraint on email
+        swapContract(ctx, 'contract-unique-email');
         const emit1 = await runContractEmit(ctx);
-        expect(emit1.exitCode, 'emit additive-required').toBe(0);
-        const plan1 = await runMigrationPlan(ctx, ['--name', 'add-required-name']);
-        expect(plan1.exitCode, 'plan add-required-name').toBe(0);
+        expect(emit1.exitCode, 'emit unique-email').toBe(0);
+        const plan1 = await runMigrationPlan(ctx, ['--name', 'add-unique-email']);
+        expect(plan1.exitCode, 'plan add-unique-email').toBe(0);
 
-        // Apply fails because the planner's empty-table precheck rejects adding
-        // a NOT NULL + UNIQUE column to a non-empty table (temporary default
-        // strategy is disabled when the column has a UNIQUE constraint).
+        // Apply fails because duplicate emails violate the unique constraint
         const applyFail = await runMigrationApply(ctx, ['--json']);
-        expect(applyFail.exitCode, 'apply fails on non-empty table precheck').toBe(1);
+        expect(applyFail.exitCode, 'apply fails on duplicate key').toBe(1);
 
         // Marker stays at the first migration's target hash
         const marker = await sql(
@@ -121,9 +119,13 @@ withTempDir(({ createTempDir }) => {
           firstResult.markerHash,
         );
 
-        // Fix: remove conflicting data, then resume
-        await sql(db.connectionString, 'DELETE FROM "user"');
+        // Fix: deduplicate emails
+        await sql(
+          db.connectionString,
+          `UPDATE "user" SET email = 'unique@example.com' WHERE id = 2`,
+        );
 
+        // Resume: apply succeeds now that duplicates are resolved
         const applyResume = await runMigrationApply(ctx, ['--json']);
         expect(applyResume.exitCode, 'resume succeeds').toBe(0);
 

test/integration/test/cli.migration-apply.e2e.test.ts

@@ -314,32 +314,30 @@ withTempDir(({ createTempDir }) => {
             const firstApply = JSON.parse(consoleOutput.join('\n').trim()) as MigrationApplyResult;
             expect(firstApply.migrationsApplied).toBe(1);
 
-            // Insert data so a later NOT NULL column addition will fail.
+            // Insert rows with duplicate emails so a unique constraint will fail.
             await withClient(connectionString, async (client) => {
-              await client.query(`INSERT INTO "user" (id, email) VALUES (1, 'user@example.com')`);
+              await client.query(
+                `INSERT INTO "user" (id, email) VALUES (1, 'dup@example.com'), (2, 'dup@example.com')`,
+              );
             });
 
-            // Plan second migration that adds a NOT NULL + UNIQUE column.
-            // The UNIQUE constraint prevents the planner's temporary-default
-            // strategy (a uniform default would violate uniqueness), so the
-            // planner falls back to an empty-table precheck that fails here.
+            // Plan second migration that adds a unique constraint on email.
             replaceInFileOrThrow(
               contractPath!,
               '        email: field.column(textColumn),\n',
-              `        email: field.column(textColumn),\n        required_name: field.column(textColumn).unique({ name: 'user_required_name_key' }),\n`,
+              `        email: field.column(textColumn).unique({ name: 'user_email_key' }),\n`,
             );
 
             await emitContract(testDir, configPath);
             await runMigrationPlan(testDir, [
               '--config',
               configPath,
               '--name',
-              'add_required_name',
+              'add_unique_email',
               '--no-color',
             ]);
 
-            // Apply fails: the empty-table precheck rejects adding a NOT NULL + UNIQUE
-            // column to a non-empty table.
+            // Apply fails: duplicate emails violate the unique constraint.
             consoleOutput.length = 0;
             let failed = false;
             try {
@@ -349,9 +347,6 @@ withTempDir(({ createTempDir }) => {
             }
             expect(failed).toBe(true);
             expect(getExitCode()).toBe(1);
-            const errorOutput = stripAnsi(consoleOutput.join('\n'));
-            expect(errorOutput).toContain('failed during precheck');
-            expect(errorOutput).toContain('is empty before adding NOT NULL column');
 
             // Marker must remain at the first migration hash (resume point).
             const migrationsDir = join(testDir, 'migrations');
@@ -371,9 +366,9 @@ withTempDir(({ createTempDir }) => {
               expect(marker.rows[0]?.core_hash).toBe(firstMigration!.manifest.to);
             });
 
-            // Make second migration runnable, then re-run apply; it should resume from marker.
+            // Fix: deduplicate emails, then re-run apply; it should resume from marker.
             await withClient(connectionString, async (client) => {
-              await client.query('DELETE FROM "user"');
+              await client.query(`UPDATE "user" SET email = 'unique@example.com' WHERE id = 2`);
             });
 
             consoleOutput.length = 0;

test/integration/test/fixtures/cli/cli-e2e-test-app/fixtures/cli-journeys/contract-unique-email.ts

@@ -0,0 +1,16 @@
+import type { CodecTypes } from '@prisma-next/adapter-postgres/codec-types';
+import { int4Column, textColumn } from '@prisma-next/adapter-postgres/column-types';
+import { defineContract } from '@prisma-next/sql-contract-ts/contract-builder';
+import postgresPack from '@prisma-next/target-postgres/pack';
+
+export const contract = defineContract<CodecTypes>()
+  .target(postgresPack)
+  .table('user', (t) =>
+    t
+      .column('id', { type: int4Column, nullable: false })
+      .column('email', { type: textColumn, nullable: false })
+      .primaryKey(['id'])
+      .unique(['email'], 'user_email_key'),
+  )
+  .model('User', 'user', (m) => m.field('id', 'id').field('email', 'email'))
+  .build();