feat(postgres,sqlite): add typed temp table creation in transactions

Signed-off-by: paulwer <paul@wer-ner.de>

Author: paulwer

packages/2-sql/5-runtime/src/sql-runtime.ts

@@ -115,6 +115,13 @@ export interface RuntimeConnection extends RuntimeQueryable {
 export interface RuntimeTransaction extends RuntimeQueryable {
   commit(): Promise<void>;
   rollback(): Promise<void>;
+  /**
+   * Register a hook to run immediately before the transaction is committed.
+   * Hooks are invoked in registration order and awaited sequentially. If any
+   * hook throws, the commit is aborted and the error propagates to the caller.
+   * Not invoked on rollback.
+   */
+  registerPreCommitHook(hook: () => Promise<void>): void;
 }
 
 export interface RuntimeQueryable extends RuntimeScope {
@@ -133,6 +140,13 @@ export interface RuntimeQueryable extends RuntimeScope {
 
 export interface TransactionContext extends RuntimeQueryable {
   readonly invalidated: boolean;
+  /**
+   * Register a hook to run immediately before the transaction is committed.
+   * Hooks are invoked in registration order and awaited sequentially. If any
+   * hook throws, the commit is aborted and the error propagates to the caller.
+   * Not invoked on rollback.
+   */
+  registerPreCommitHook(hook: () => Promise<void>): void;
 }
 
 export type { RuntimeTelemetryEvent, TelemetryOutcome, VerifyMarkerOption };
@@ -651,8 +665,15 @@ export abstract class SqlRuntimeBase<TContract extends Contract<SqlStorage> = Co
 
   private wrapTransaction(driverTx: SqlTransaction): RuntimeTransaction {
     const self = this;
+    const preCommitHooks: Array<() => Promise<void>> = [];
     return {
+      registerPreCommitHook(hook: () => Promise<void>): void {
+        preCommitHooks.push(hook);
+      },
       async commit(): Promise<void> {
+        for (const hook of preCommitHooks) {
+          await hook();
+        }
         await driverTx.commit();
       },
       async rollback(): Promise<void> {
@@ -808,6 +829,12 @@ export async function withTransaction<R>(
         guardedStream(transaction.executePrepared(ps, params, options)),
       );
     },
+    registerPreCommitHook(hook: () => Promise<void>): void {
+      if (invalidated) {
+        throw transactionClosedError();
+      }
+      transaction.registerPreCommitHook(hook);
+    },
   };
 
   let connectionDisposed = false;

packages/2-sql/5-runtime/test/sql-runtime.test.ts

@@ -28,7 +28,7 @@ import type {
   SqlRuntimeTargetDescriptor,
 } from '../src/sql-context';
 import { createExecutionContext, createSqlExecutionStack } from '../src/sql-context';
-import { withTransaction } from '../src/sql-runtime';
+import { type TempTableQuerySource, withTransaction } from '../src/sql-runtime';
 import { createAsyncSecretCodec, decryptSecret } from './seeded-secret-codec';
 import { defineTestCodec } from './test-codec';
 import { createTestRuntime as createRuntime, descriptorsFromCodecs, stubAst } from './utils';
@@ -939,3 +939,110 @@ describe('withTransaction', () => {
     expect(driver.__spies.transactionRollback).toHaveBeenCalledTimes(1);
   });
 });
+
+describe('RuntimeTransaction.registerPreCommitHook', () => {
+  function createRuntimeForHooks() {
+    const { stackInstance, context, driver } = createTestSetup();
+    const runtime = createRuntime({ stackInstance, context, driver, verifyMarker: false });
+    return { runtime, driver };
+  }
+
+  it('runs the hook before driverTx.commit()', async () => {
+    const { runtime, driver } = createRuntimeForHooks();
+    const order: string[] = [];
+    driver.__spies.transactionCommit.mockImplementation(async () => {
+      order.push('commit');
+    });
+
+    const conn = await runtime.connection();
+    const tx = await conn.transaction();
+    tx.registerPreCommitHook(async () => {
+      order.push('hook');
+    });
+    await tx.commit();
+    await conn.release();
+
+    expect(order).toEqual(['hook', 'commit']);
+  });
+
+  it('runs multiple hooks in registration order before commit', async () => {
+    const { runtime, driver } = createRuntimeForHooks();
+    const order: string[] = [];
+    driver.__spies.transactionCommit.mockImplementation(async () => {
+      order.push('commit');
+    });
+
+    const conn = await runtime.connection();
+    const tx = await conn.transaction();
+    tx.registerPreCommitHook(async () => {
+      order.push('hook-1');
+    });
+    tx.registerPreCommitHook(async () => {
+      order.push('hook-2');
+    });
+    tx.registerPreCommitHook(async () => {
+      order.push('hook-3');
+    });
+    await tx.commit();
+    await conn.release();
+
+    expect(order).toEqual(['hook-1', 'hook-2', 'hook-3', 'commit']);
+  });
+
+  it('aborts commit and propagates the error when a hook throws', async () => {
+    const { runtime, driver } = createRuntimeForHooks();
+    const hookError = new Error('hook failed');
+
+    const conn = await runtime.connection();
+    const tx = await conn.transaction();
+    tx.registerPreCommitHook(async () => {
+      throw hookError;
+    });
+
+    await expect(tx.commit()).rejects.toBe(hookError);
+    expect(driver.__spies.transactionCommit).not.toHaveBeenCalled();
+    await conn.release();
+  });
+
+  it('does not invoke subsequent hooks after an earlier hook throws', async () => {
+    const { runtime, driver } = createRuntimeForHooks();
+    const hook2 = vi.fn();
+
+    const conn = await runtime.connection();
+    const tx = await conn.transaction();
+    tx.registerPreCommitHook(async () => {
+      throw new Error('hook-1 failed');
+    });
+    tx.registerPreCommitHook(hook2);
+
+    await tx.commit().catch(() => {});
+
+    expect(hook2).not.toHaveBeenCalled();
+    expect(driver.__spies.transactionCommit).not.toHaveBeenCalled();
+    await conn.release();
+  });
+
+  it('does not invoke hooks on rollback', async () => {
+    const { runtime } = createRuntimeForHooks();
+    const hook = vi.fn();
+
+    const conn = await runtime.connection();
+    const tx = await conn.transaction();
+    tx.registerPreCommitHook(hook);
+    await tx.rollback();
+    await conn.release();
+
+    expect(hook).not.toHaveBeenCalled();
+  });
+
+  it('no hooks registered — commit proceeds normally', async () => {
+    const { runtime, driver } = createRuntimeForHooks();
+
+    const conn = await runtime.connection();
+    const tx = await conn.transaction();
+    await tx.commit();
+    await conn.release();
+
+    expect(driver.__spies.transactionCommit).toHaveBeenCalledOnce();
+  });
+});