@spfn/core 0.3.0-beta.5 → 0.3.0-beta.6

package/README.md

@@ -185,18 +185,144 @@ import type { AppRouter } from '@/server/router';
 
 export const api = createApi<AppRouter>();
 
-// anywhere — server component, client component, or server action:
+// the same client in a Server Component, a Client Component or a Server Action:
 const user = await api.getUser.call({ params: { id: '123' } });    // typed { id, name }
 const made = await api.createUser.call({ body: { name: 'A' } });
 ```
 
+That the client is isomorphic does not make the three callers interchangeable. **A page's
+initial data is awaited in the Server Component**, where
+`api.getUser.fetchOptions({ next: { revalidate, tags } }).call(…)` participates in
+Next.js caching and reaches the backend without a browser round trip. Fetching that same
+first paint from a `'use client'` component inside a `useEffect` is the anti-pattern: it
+ships a loading state and a second network hop for data the server already had. Client
+Components and Server Actions are for what happens after the first paint — interaction
+and mutation. Cache tags, revalidation and SSR cookie forwarding are in
+[the Next.js bridge docs](https://superfunction.xyz/docs/packages/core/nextjs).
+
+---
+
+## How does a repository talk to the database?
+
+Through `BaseRepository`. Extending it gives a repository two transaction-aware
+connections — `this.db` (write/primary) and `this.readDb` (the replica, when one is
+configured) — plus the CRUD set as protected methods.
+
+```typescript
+// server/repositories/order.ts
+import { BaseRepository } from '@spfn/core/db';
+import { desc } from 'drizzle-orm';
+import { orders } from '../entities/order';
+
+export class OrderRepository extends BaseRepository
+{
+    findRecentFor(userId: string)
+    {
+        return this._findMany(orders, { where: { userId }, orderBy: desc(orders.createdAt) });
+    }
+
+    place(data: { userId: string; total: number })
+    {
+        return this._create(orders, data);
+    }
+}
+
+export const orderRepo = new OrderRepository();
+```
+
+Handlers never import drizzle query builders; repositories do. `_findMany` reads through
+`this.readDb`, `_create` writes through `this.db`, and both getters resolve to the active
+transaction's connection when there is one — so the same method is correct inside a
+transaction and outside it. When a helper cannot express a query, drop to
+`this.readDb.select()…` inside the repository rather than in the handler. The full
+protected CRUD set is in [src/db](./src/db/README.md).
+
+---
+
+## Where do transactions and their side effects go?
+
+`Transactional()` covers the route case — commit on return, rollback on throw. Two rules
+decide the rest.
+
+**Nothing takes a `tx` parameter.** The transaction travels in AsyncLocalStorage, so
+`this.db` inside a repository already resolves to it. A service that accepts `tx` and
+threads it downward re-implements propagation that already happened, and the first caller
+that forgets to pass it writes outside the transaction. For a service, script or job with
+no route around it, open one with `runInTransaction(fn, options?)`;
+`runWithTransaction(tx, txId, fn)` is the lower-level primitive that binds an existing
+Drizzle transaction into the context.
+
+**Side effects go on the commit hooks, not inline.** An event emitted or a mail sent from
+inside the transaction still went out when the transaction later rolls back.
+
+| Hook | When it runs | What it is for |
+|---|---|---|
+| `onBeforeCommit(fn)` | Inside the still-open transaction, just before commit — a throw aborts and rolls back | Last-moment invariant checks, and statements that must land in the same commit |
+| `onAfterCommit(fn)` | After the root transaction commits, outside the transaction context; errors are logged, never thrown | Events, mail, cache invalidation — anything the outside world observes |
+| `onAfterRollback(fn)` | After the root transaction rolls back, before the causing error propagates; errors are logged, never thrown | Undoing external work that cannot roll itself back, such as an object already uploaded |
+
+All three import from `@spfn/core/db`, can be registered anywhere inside the transaction,
+and bubble to the **root** transaction — a nested block's callbacks fire on the outermost
+outcome, not on a savepoint's.
+
+```typescript
+import { runInTransaction, onAfterCommit } from '@spfn/core/db';
+
+export async function placeOrder(input: { userId: string; total: number })
+{
+    return runInTransaction(async () =>
+    {
+        const order = await orderRepo.place(input);   // no tx argument, at any depth
+        onAfterCommit(() => orderPlacedEvent.emit({ orderId: order.id }));
+
+        return order;
+    });
+}
+```
+
+---
+
+## What else can defineServerConfig configure?
+
+`.port()` and `.routes()` are the two every app calls. The rest of the builder is how an
+app wires its infrastructure without touching the server's boot sequence. Every method
+returns the builder; `.build()` ends the chain.
+
+| Method | What it configures |
+|---|---|
+| `.port(n)` / `.host(s)` | Where the server listens |
+| `.routes(router)` | The `defineRouter` router to mount, with its own `.use()` and `.packages()` |
+| `.jobs(router, config?)` | Background jobs — a `defineJobRouter`, plus pg-boss options |
+| `.events(router, config?)` | SSE streaming — a `defineEventRouter`, served at `GET /events/stream` |
+| `.websockets(router, config?)` | Bidirectional WebSockets — a `defineWSRouter`, served at `WS /ws` |
+| `.workflows(router, config?)` | `@spfn/workflow` orchestration; the engine starts once the database is ready |
+| `.lifecycle(hooks)` | Boot and shutdown hooks. Callable more than once; hooks run in registration order |
+| `.migrations(opts)` | The migration boot gate — `{ allowPending: true }` lets a server start behind its migrations |
+| `.database(opts)` | Connection and pool settings |
+| `.infrastructure(opts)` | Which infrastructure is initialized at boot |
+| `.healthCheck(opts)` | The health endpoint |
+| `.serverTime(clock)` | The clock behind `GET /_core/time`; normally left at the default |
+| `.middleware(opts)` | The built-in middleware — `ErrorHandler`, `RequestLogger` |
+| `.use(handlers)` | Additional global Hono middleware |
+| `.middlewares(named)` | Global middleware under names, so a route can `.skip([...])` it |
+| `.cors(opts)` | CORS |
+| `.rateLimit(opts)` | A global default limiter plus the named policies routes resolve against |
+| `.proxyGuard(opts)` | Trusted-proxy signature and origin verification, resolved to a `clientType` |
+| `.outboundFetch(opts)` | The SSRF policy `safeFetch` applies to outbound calls |
+| `.timeout(opts)` / `.shutdown(opts)` | Request timeouts and graceful shutdown |
+| `.debug(bool)` | Debug logging |
+
+The options each one takes are in [src/server](./src/server/README.md).
+
 ---
 
 ## Which import path do I use for what?
 
 There is **no root barrel**: `import … from '@spfn/core'` does not resolve. Every symbol
 comes from a subpath, and the table below is the complete public surface — one row per
-entry in `package.json` `exports`. Each module has its own README with the API detail.
+entry in `package.json` `exports`, with a single exclusion: `./client` is still listed in
+`exports` but the build no longer emits it, so it has no row (see [Pitfalls](#pitfalls)).
+Each module has its own README with the API detail.
 
 | Import path | Purpose | Doc |
 |-------------|---------|-----|
@@ -207,16 +333,17 @@ entry in `package.json` `exports`. Each module has its own README with the API d
 | `@spfn/core/nextjs/server` | Server-only: `createRpcProxy({ routeMap })`, `registerInterceptors`. Uses `next/headers`. | [src/nextjs](./src/nextjs/README.md) |
 | `@spfn/core/db` | PostgreSQL through Drizzle: CRUD helpers, `BaseRepository`, schema helpers, transactions, Postgres error mapping. One entry point for all of it. | [src/db](./src/db/README.md) |
 | `@spfn/core/db` → manager | Connection lifecycle, pool, primary/replica, health check, reconnect (`initDatabase`, `getDatabase`). Re-exported from `@spfn/core/db`. | [src/db/manager](./src/db/manager/README.md) |
-| `@spfn/core/db` → migrations | Which migrations each installed function package ships, and which the database has applied (`collectMigrationStatus`, `discoverFunctionMigrations`). What `spfn db status`, the boot gate and health all read. Re-exported from `@spfn/core/db`. | [src/db/migrations](./src/db/migrations/index.ts) |
+| `@spfn/core/db` → migrations | Which migrations each installed function package ships, and which the database has applied (`collectMigrationStatus`, `discoverFunctionMigrations`). What `spfn db status`, the boot gate and health all read. Re-exported from `@spfn/core/db`. | [src/db/migrations](https://github.com/fxylabs/spfn/blob/main/packages/core/src/db/migrations/index.ts) |
 | `@spfn/core/db` → schema | Drizzle column helpers (`id`, `uuid`, `timestamps`, `foreignKey`, `enumText`, `typedJsonb`, `softDelete`, …). Re-exported from `@spfn/core/db`. | [src/db/schema](./src/db/schema/README.md) |
 | `@spfn/core/db` → transaction | `Transactional()` middleware and `runInTransaction`; the transaction reaches every repository through AsyncLocalStorage. Re-exported from `@spfn/core/db`. | [src/db/transaction](./src/db/transaction/README.md) |
 | `@spfn/core/middleware` | Built-in Hono middleware: `ErrorHandler`, `RequestLogger` and its masking helper. | [src/middleware](./src/middleware/README.md) |
 | `@spfn/core/errors` | Serializable HTTP and database error classes, plus `ErrorRegistry` so an error survives the trip to the client as its own class. | [src/errors](./src/errors/README.md) |
 | `@spfn/core/security` | `safeFetch` — a drop-in `fetch` hardened against SSRF, including DNS rebinding, by pinning the connection to a validated IP. | [src/security](./src/security/README.md) |
-| `@spfn/core/authz` | Ownership guards. `requireOwner(resource, userId)` makes "load it, then check it belongs to the requester" one call, so a handler cannot forget it. | [src/authz/index.ts](./src/authz/index.ts) |
+| `@spfn/core/authz` | Ownership guards. `requireOwner(resource, userId)` makes "load it, then check it belongs to the requester" one call, so a handler cannot forget it. | [src/authz/index.ts](https://github.com/fxylabs/spfn/blob/main/packages/core/src/authz/index.ts) |
 | `@spfn/core/env` | Schema-based environment validation, isomorphic. | [src/env](./src/env/README.md) |
 | `@spfn/core/env/loader` | The **server-only** `.env` file loader (uses `node:fs`). | [src/env](./src/env/README.md) |
 | `@spfn/core/config` | `@spfn/core`'s own validated env config (`env`, `envSchema`, `registry`), built on `@spfn/core/env`. | [src/config](./src/config/README.md) |
+| `@spfn/core/app-config` | Reads `spfn.config.js` — the one committed place that says which ports and host the app is served on (`loadAppConfig`, `resolvePorts`, `resolveHost`, `PORT_DEFAULTS`). Deliberately side-effect free, so the CLI can import it before an app's environment exists. | [src/app-config/index.ts](https://github.com/fxylabs/spfn/blob/main/packages/core/src/app-config/index.ts) |
 | `@spfn/core/logger` | Structured singleton `logger` with child loggers and level masking. No dependencies. | [src/logger](./src/logger/README.md) |
 | `@spfn/core/cache` | Valkey/Redis singleton over ioredis (`getCache`, `getCacheRead`). Degrades to disabled rather than throwing. | [src/cache](./src/cache/README.md) |
 | `@spfn/core/job` | Background jobs on pg-boss: a fluent `job()` builder, cron, run-once, event-driven, `defineJobRouter`. | [src/job](./src/job/README.md) |
@@ -227,6 +354,7 @@ entry in `package.json` `exports`. Each module has its own README with the API d
 | `@spfn/core/event/ws/client` | Browser WebSocket client. | [src/event](./src/event/README.md) |
 | `@spfn/core/codegen` | The codegen orchestrator and the built-in generators: `@spfn/core:route-map` for the proxy's route map, `@spfn/core:contract` for the client contract. | [src/codegen](./src/codegen/README.md) |
 | `@spfn/core/contract` | Route contracts for clients that ship separately: collect, snapshot, and the build gate that refuses a breaking change. | [src/contract](./src/contract/README.md) |
+| `@spfn/core/ops` | The operations surface `spfn ops` drives: `opsRoute`, `createOpsRouter`, `defineOpsModule`, and the manifest the CLI discovers commands from. Structure only — the router is always authenticated, and token verification lives in `@spfn/auth`. | [How do I operate the app from the terminal?](#how-do-i-operate-the-app-from-the-terminal) |
 
 `db/manager`, `db/schema` and `db/transaction` are **not** package subpaths of their own.
 They are internal modules re-exported by `@spfn/core/db` — import their symbols from

package/dist/db/index.d.ts

@@ -397,27 +397,6 @@ declare function getDatabaseInfo(): {
     providerKind?: string;
 };
 
-/**
- * Reconnect Trigger — Query-error driven pool rebuild
- *
- * Complements the periodic health check with a fast-path: when application
- * queries start failing with connection-level errors, we do not wait up to
- * DB_HEALTH_CHECK_INTERVAL (default 60s) to notice. A sliding-window counter
- * trips a force-reconnect as soon as the failure rate crosses a threshold.
- *
- * Why this exists:
- *  - postgres.js transparently drops dead sockets and opens new ones on the
- *    next query. A single `SELECT 1` on the periodic interval can therefore
- *    false-pass while user-facing queries keep hitting the remaining dead
- *    sockets in the pool.
- *  - This module observes real query errors and, when it sees a burst of
- *    connection-level failures, calls triggerForceReconnect() which performs
- *    the same atomic-swap rebuild as the health check.
- *
- * Configuration (env vars, hardcoded defaults):
- *  - DB_RECONNECT_ERROR_THRESHOLD (default 3): errors needed in window
- *  - DB_RECONNECT_ERROR_WINDOW_MS (default 10000): sliding window size
- */
 /**
  * Determine whether an error looks like a pool/connection failure
  *
@@ -1139,6 +1118,23 @@ type TransactionDB<TDatabase extends DrizzleDatabase = DefaultDatabase> = Databa
  * afterCommit callback type
  */
 type AfterCommitCallback = () => void | Promise<void>;
+/**
+ * beforeCommit callback type
+ */
+type BeforeCommitCallback = () => void | Promise<void>;
+/**
+ * afterRollback callback type
+ */
+type AfterRollbackCallback = () => void | Promise<void>;
+/**
+ * Serializes the savepoint frames opened directly off one transaction context
+ *
+ * @see createNestedFrameGate
+ */
+type NestedFrameGate = {
+    /** Run `frame` once every frame queued before it on this context has finished */
+    run<T>(frame: () => Promise<T>): Promise<T>;
+};
 /**
  * Transaction context stored in AsyncLocalStorage
  */
@@ -1148,8 +1144,14 @@ type TransactionContext<TDatabase extends DrizzleDatabase = DrizzleDatabase> = {
     /** Unique transaction ID for logging and tracing */
     txId: string;
     level: number;
+    /** Callbacks to execute before the root transaction commits (still inside it) */
+    beforeCommitCallbacks: BeforeCommitCallback[];
     /** Callbacks to execute after root transaction commits */
     afterCommitCallbacks: AfterCommitCallback[];
+    /** Callbacks to execute after the root transaction rolled back */
+    afterRollbackCallbacks: AfterRollbackCallback[];
+    /** Serializes the savepoint frames opened directly off THIS context */
+    nestedFrames: NestedFrameGate;
 };
 /**
  * Get current transaction object and metadata from AsyncLocalStorage
@@ -1187,7 +1189,7 @@ callback: () => Promise<T>): Promise<T>;
  *
  * @example
  * ```typescript
- * import { onAfterCommit } from '@spfn/core/db/transaction';
+ * import { onAfterCommit } from '@spfn/core/db';
  *
  * async function submit(spaceId: string, chatId: string)
  * {
@@ -1201,6 +1203,77 @@ callback: () => Promise<T>): Promise<T>;
  * ```
  */
 declare function onAfterCommit(callback: AfterCommitCallback): void;
+/**
+ * Register a callback to run just before the current transaction commits
+ *
+ * - Inside a transaction: queued and executed after the root callback resolves,
+ *   while the transaction is still open — the callback MAY run statements and
+ *   they are part of the same commit
+ * - Outside a transaction: executed immediately with a WARNING (same rationale as
+ *   onAfterCommit — there is nothing left to commit), and the abort semantics
+ *   below do not apply: there is no transaction for a throw to roll back
+ * - Nested transactions: callbacks bubble up to root transaction
+ * - Callbacks run in registration order, inside the transaction context
+ *   (getTransaction() returns the live tx)
+ * - The queue is snapshot before the pass, so a callback registered BY a
+ *   beforeCommit callback does not run for this commit — it would otherwise
+ *   grow the queue mid-iteration and loop forever inside the open transaction
+ * - A throw ABORTS: later callbacks are skipped, the transaction rolls back,
+ *   the error propagates to the caller, and afterRollback callbacks fire
+ *
+ * @example
+ * ```typescript
+ * import { runInTransaction, onBeforeCommit } from '@spfn/core/db';
+ *
+ * async function transfer(fromId: string, toId: string, amount: number)
+ * {
+ *     // The transaction is what gives the check teeth — registered outside one,
+ *     // the callback runs immediately and its throw aborts nothing.
+ *     await runInTransaction(async () =>
+ *     {
+ *         await accountRepo.debit(fromId, amount);
+ *         await accountRepo.credit(toId, amount);
+ *
+ *         // Last-moment invariant check: a throw here rolls the whole transfer back.
+ *         onBeforeCommit(() => assertNoNegativeBalance(fromId));
+ *     });
+ * }
+ * ```
+ */
+declare function onBeforeCommit(callback: BeforeCommitCallback): void;
+/**
+ * Register a callback to run after the current transaction rolled back
+ *
+ * - Inside a transaction: queued and executed after the ROOT transaction rolled
+ *   back, before the causing error leaves runInTransaction / the middleware
+ * - Outside a transaction: no-op with a warning — there is no rollback to wait for
+ * - Nested transactions: callbacks bubble up to root transaction. A nested
+ *   rollback that the root survives does NOT fire them; these hooks are about
+ *   the root transaction's fate, not a savepoint's
+ * - Callbacks run outside the transaction context (new connection for DB access)
+ * - Errors are logged but never thrown: the original error keeps propagating
+ *   unchanged, never replaced by a callback failure
+ *
+ * @example
+ * ```typescript
+ * import { runInTransaction, onAfterRollback } from '@spfn/core/db';
+ *
+ * async function importAvatar(userId: string, file: Blob)
+ * {
+ *     // Upload first: external I/O never belongs inside the transaction.
+ *     const key = await objectStore.put(file);
+ *
+ *     await runInTransaction(async () =>
+ *     {
+ *         await userRepo.updateAvatar(userId, key);
+ *
+ *         // The upload cannot roll back on its own — undo it if the write never lands.
+ *         onAfterRollback(() => objectStore.delete(key));
+ *     });
+ * }
+ * ```
+ */
+declare function onAfterRollback(callback: AfterRollbackCallback): void;
 
 /**
  * Transaction middleware options
@@ -1245,6 +1318,21 @@ interface TransactionalOptions {
      * @default 30000 (30s) or TRANSACTION_IDLE_TIMEOUT environment variable
      */
     idleTimeout?: number;
+    /**
+     * Run in an independent transaction instead of joining an ambient one.
+     *
+     * Only bites when the middleware itself runs nested — a sub-app mounted
+     * under a route that already applied `Transactional()`, or a handler invoked
+     * from inside `runInTransaction`. By default that inner run takes a SAVEPOINT
+     * on the outer transaction; `requiresNew: true` gives it a real `BEGIN` on a
+     * second pooled connection, with its own timeouts and its own hook queues.
+     *
+     * See `RunInTransactionOptions.requiresNew` for the pool and self-deadlock
+     * costs — they apply here unchanged.
+     *
+     * @default false
+     */
+    requiresNew?: boolean;
 }
 /**
  * Transaction middleware for Hono routes
@@ -1282,6 +1370,9 @@ interface TransactionalOptions {
  * - Success: Auto-commit
  * - Error: Auto-rollback
  * - Detects context.error to trigger rollback
+ * - Hooks: this delegates to runInTransaction, so onBeforeCommit, onAfterCommit
+ *   and onAfterRollback behave exactly as they do there. afterRollback callbacks
+ *   have already run by the time the error reaches the conversion below.
  *
  * 📊 Transaction logging:
  * - Auto-logs transaction start/commit/rollback
@@ -1317,8 +1408,12 @@ interface RunInTransactionOptions {
      * - `timeout: undefined` - Uses default (30s or TRANSACTION_TIMEOUT env var)
      * - `timeout: N` - Sets timeout to N milliseconds (1 to 2147483647)
      *
-     * Note: Timeout is only applied to root transactions. Nested transactions
-     * (SAVEPOINTs) inherit the timeout from the outer transaction.
+     * Note: Timeout is only applied to root transactions. A nested call takes a
+     * SAVEPOINT on the outer transaction's connection, where the outer
+     * transaction's `SET LOCAL statement_timeout` is already in force — so the
+     * nested call genuinely inherits it, and its own `timeout` is ignored (a
+     * warning is logged when the caller passed one explicitly). A
+     * `requiresNew: true` call is a root and gets its own.
      *
      * @default 30000 (30 seconds) or TRANSACTION_TIMEOUT environment variable
      *
@@ -1355,6 +1450,48 @@ interface RunInTransactionOptions {
      * @default 'transaction'
      */
     context?: string;
+    /**
+     * Run in an independent transaction instead of joining an ambient one.
+     *
+     * By default a call made while another transaction is open takes a SAVEPOINT
+     * on that transaction's connection: its writes commit or roll back with the
+     * outer transaction. `requiresNew: true` opens a real `BEGIN` on a SECOND
+     * pooled connection instead, so the work commits on its own and survives an
+     * outer rollback — an audit trail or a failed-attempt record, for example.
+     *
+     * Being a root transaction, it gets its own `statement_timeout`,
+     * `idle_in_transaction_session_timeout`, and its OWN hook queues:
+     * `onBeforeCommit` / `onAfterCommit` / `onAfterRollback` registered inside it
+     * fire on ITS outcome, not the outer transaction's.
+     *
+     * Two costs, both consequences of the second connection:
+     * - It holds a second connection for its whole duration, so it counts twice
+     *   against the pool. Keep it short and don't fan it out.
+     * - It cannot see the outer transaction's uncommitted writes, and it BLOCKS
+     *   on any row the outer transaction has locked. Since the outer transaction
+     *   is waiting for this call to return, that block is a self-deadlock that
+     *   only `statement_timeout` breaks. Never touch rows the outer transaction
+     *   wrote.
+     *
+     * @default false
+     *
+     * @example
+     * ```typescript
+     * await runInTransaction(async () =>
+     * {
+     *     await orderRepo.create(order);
+     *
+     *     // Lands even if the order below rolls the outer transaction back.
+     *     await runInTransaction(
+     *         () => auditRepo.record('order.attempted', order.id),
+     *         { requiresNew: true },
+     *     );
+     *
+     *     await inventoryRepo.reserve(order.items);   // may throw
+     * });
+     * ```
+     */
+    requiresNew?: boolean;
 }
 /**
  * Run a callback function within a database transaction
@@ -1366,6 +1503,15 @@ interface RunInTransactionOptions {
  * - Warns about slow transactions
  * - Enforces timeout if configured
  *
+ * Called with a transaction already open on the async call chain, it takes a
+ * SAVEPOINT on that transaction rather than opening an independent one: the work
+ * runs on the same connection, sees the outer transaction's uncommitted writes,
+ * and commits with it. A throw that the caller catches unwinds to the SAVEPOINT
+ * and leaves the outer transaction healthy; a throw that propagates rolls the
+ * whole thing back. Nested calls off one transaction are serialized — see
+ * `openTransaction` — so `Promise.all` over them runs them one at a time. Pass
+ * `requiresNew: true` for an independent transaction on its own connection.
+ *
  * Errors are propagated to the caller without modification.
  * Caller is responsible for error handling and conversion.
  *
@@ -1680,11 +1826,11 @@ declare function count<T extends PgTable>(table: T, where?: WhereObject<InferSel
  *
  * @example With Transactions
  * ```typescript
- * import { runWithTransaction } from '@spfn/core/db';
+ * import { runInTransaction } from '@spfn/core/db';
  *
  * const userRepo = new UserRepository();
  *
- * await runWithTransaction(async () => {
+ * await runInTransaction(async () => {
  *     // Both db and readDb automatically use the transaction context
  *     const user = await userRepo.create({ name: 'John' });
  *     await userRepo.findById(user.id); // Uses same transaction
@@ -2006,4 +2152,4 @@ declare abstract class BaseRepository<TRelations extends AnyRelations = EmptyRel
     protected _count<T extends PgTable>(table: T, where?: Record<string, any> | SQL | undefined): Promise<number>;
 }
 
-export { type AfterCommitCallback, BaseRepository, type DatabaseClients, type DatabaseInitOptions, type DatabaseOptions, type DatabaseProvider, type DatabaseTransaction, type DefaultDatabase, type DrizzleConfigOptions, type DrizzleDatabase, type FunctionMigrationEntry, type FunctionMigrationInfo, type MigrationStatus, type MigrationStatusDb, type MigrationTargetStatus, PROJECT_MIGRATIONS_TABLE, PROJECT_TARGET_NAME, type PoolConfig, RUN_MIGRATIONS_HINT, type RepositoryDatabase, RepositoryError, type RetryConfig, type RunInTransactionOptions, type TransactionContext, type TransactionDB, Transactional, type TransactionalOptions, auditFields, checkConnection, closeDatabase, collectMigrationStatus, count, countPendingMigrations, create, createDatabaseConnection, createDatabaseFromEnv, createMany, createSchema, deleteMany, deleteOne, detectDialect, discoverFunctionMigrations, enumText, filterPendingEntries, findMany, findOne, forceReconnectDatabase, foreignKey, formatPendingMigrations, fromPostgresError, functionMigrationsTable, generateDrizzleConfigFile, getDatabase, getDatabaseInfo, getDrizzleConfig, getSchemaInfo, getTransaction, getTransactionContext, hasMigrationTargets, id, initDatabase, isConnectionLevelError, migrationTargets, onAfterCommit, optionalForeignKey, packageNameToSchema, pendingMigrationTargets, pendingMigrationsSummary, projectMigrationsDir, publishingFields, readMigrationEntries, reportDatabaseError, resetConnectionErrorCounter, runInTransaction, runWithTransaction, setDatabase, setDatabaseProvider, softDelete, timestamps, typedJsonb, updateMany, updateOne, upsert, utcTimestamp, uuid, verificationTimestamp };
+export { type AfterCommitCallback, type AfterRollbackCallback, BaseRepository, type BeforeCommitCallback, type DatabaseClients, type DatabaseInitOptions, type DatabaseOptions, type DatabaseProvider, type DatabaseTransaction, type DefaultDatabase, type DrizzleConfigOptions, type DrizzleDatabase, type FunctionMigrationEntry, type FunctionMigrationInfo, type MigrationStatus, type MigrationStatusDb, type MigrationTargetStatus, type NestedFrameGate, PROJECT_MIGRATIONS_TABLE, PROJECT_TARGET_NAME, type PoolConfig, RUN_MIGRATIONS_HINT, type RepositoryDatabase, RepositoryError, type RetryConfig, type RunInTransactionOptions, type TransactionContext, type TransactionDB, Transactional, type TransactionalOptions, auditFields, checkConnection, closeDatabase, collectMigrationStatus, count, countPendingMigrations, create, createDatabaseConnection, createDatabaseFromEnv, createMany, createSchema, deleteMany, deleteOne, detectDialect, discoverFunctionMigrations, enumText, filterPendingEntries, findMany, findOne, forceReconnectDatabase, foreignKey, formatPendingMigrations, fromPostgresError, functionMigrationsTable, generateDrizzleConfigFile, getDatabase, getDatabaseInfo, getDrizzleConfig, getSchemaInfo, getTransaction, getTransactionContext, hasMigrationTargets, id, initDatabase, isConnectionLevelError, migrationTargets, onAfterCommit, onAfterRollback, onBeforeCommit, optionalForeignKey, packageNameToSchema, pendingMigrationTargets, pendingMigrationsSummary, projectMigrationsDir, publishingFields, readMigrationEntries, reportDatabaseError, resetConnectionErrorCounter, runInTransaction, runWithTransaction, setDatabase, setDatabaseProvider, softDelete, timestamps, typedJsonb, updateMany, updateOne, upsert, utcTimestamp, uuid, verificationTimestamp };