litedbmodel 2.0.2 → 2.2.0

package/dist/scp/connection-routing.d.ts

@@ -0,0 +1,312 @@
+/**
+ * litedbmodel v2 SCP — the **connection routing + config contract** (Phase C / #87).
+ *
+ * This module is the **API REFERENCE** for Phase C — the 4 native ports (rust #88 / go #89 / py #90
+ * / php #91) mirror THIS contract exactly (config field names + defaults, the connection-registry
+ * shape, `withWriter` semantics, and the `connectionFor(intent)` resolution ORDER). It builds ON the
+ * Phase A {@link import('./exec-context').ExecutionContext} seam and the Phase A/B owned-connection
+ * transaction runtime; it does NOT re-implement the seam — it supplies the pieces
+ * {@link import('./exec-context').PooledAsyncContext.connectionFor} uses to complete its resolution.
+ *
+ * ## The `connectionFor(intent)` resolution order (design §3, v1 `DBModel.ts:313` parity)
+ *
+ * A statement's connection is resolved in THIS priority (first match wins):
+ *   1. **active tx connection** — inside a transaction, always the tx-owned connection (Phase A).
+ *   2. **writer scope / writer-sticky** — inside {@link withWriter}, or within `writerStickyDuration`
+ *      after a transaction (read-your-writes), a READ goes to the WRITER pool (Phase C — here).
+ *   3. **read=reader / write=writer** — otherwise a read goes to the reader pool, a write to the
+ *      writer pool (reader/writer separation; single-pool config ⇒ reader === writer, Phase C).
+ *   4. **named-DB routing** — the target pool is selected by `intent.db` (the connection NAME carried
+ *      by the bundle/model metadata) against the {@link ConnectionRegistry}; absent ⇒ the DEFAULT
+ *      connection. Named-DB selection happens FIRST (it picks WHICH connection's reader/writer split
+ *      steps 2-3 then apply to), so the order above is really: pick the named connection, then within
+ *      it apply tx-pin / writer-sticky / reader-writer. (Phase C, decorator-free — the routing key is
+ *      config + bundle/model metadata; decorator wiring is Phase F.)
+ *
+ * ## Backward-compat (the hard constraint)
+ *
+ * Single DB, `reader === writer` (one pool), empty config, unnamed connection ⇒ BYTE-IDENTICAL to the
+ * Phase A/B single-pool behavior. A {@link ConnectionRegistry} built from ONE pool routes every
+ * intent to that ONE pool, and the writer-sticky clock only ever diverts to a pool that is the SAME
+ * object — so nothing observable changes. The existing `new PooledAsyncContext(pool)` /
+ * `new PooledAsyncContext(pool, middleware)` constructors keep working unchanged.
+ */
+import type { AsyncConnectionPool } from './exec-context';
+/**
+ * Per-connection database config (C3) — the knobs a pool is built with. Mirrors v1
+ * `DBConfig`/`DBHandler` (`src/DBHandler.ts`, `src/types.ts`): connection target + pool sizing +
+ * per-statement/keepalive/session knobs. Every field is optional with a documented default; the 4
+ * native ports MUST expose the SAME field names + defaults. This is a DATA contract — it describes
+ * how to BUILD a pool; the actual `pg.Pool` / `mysql2.createPool` construction lives in the driver
+ * adapters (`makesql/pool-executor.ts`), which read these fields.
+ */
+export interface ConnectionConfig {
+    /** Driver dialect for this connection. @default 'postgres' */
+    readonly driver?: 'postgres' | 'mysql' | 'sqlite';
+    /** DB host (server-based dialects). */
+    readonly host?: string;
+    /** DB port. */
+    readonly port?: number;
+    /** DB name (or file path for sqlite). */
+    readonly database?: string;
+    /** Username. */
+    readonly user?: string;
+    /** Password. */
+    readonly password?: string;
+    /**
+     * Per-statement timeout in MILLISECONDS. Applied as a session `statement_timeout` (PG) /
+     * `max_execution_time` (MySQL) so a runaway query is aborted by the SERVER. `0`/absent ⇒ no
+     * statement timeout (the engine default). v1 exposed this as `queryTimeout` in SECONDS on the pg
+     * CLIENT (`query_timeout`); the v2 contract is server-side ms so it fires uniformly across drivers.
+     * @default 0 (no timeout)
+     */
+    readonly queryTimeout?: number;
+    /** Enable TCP keepalive on pooled connections (recommended for serverless). @default false */
+    readonly keepAlive?: boolean;
+    /** ms before the first keepalive probe. @default 10000 (when keepAlive) */
+    readonly keepAliveInitialDelayMillis?: number;
+    /** Minimum pooled connections kept warm. @default 0 */
+    readonly minPool?: number;
+    /** Maximum pooled connections. @default 10 */
+    readonly maxPool?: number;
+    /** PG `search_path` set on each pooled connection at checkout (schema routing). */
+    readonly searchPath?: string;
+    /** MySQL connection charset / PG client_encoding set on each pooled connection. */
+    readonly charset?: string;
+}
+/** The resolved (defaults-applied) config the pool builder consumes — no `undefined` holes on the knobs. */
+export interface ResolvedConnectionConfig {
+    readonly driver: 'postgres' | 'mysql' | 'sqlite';
+    readonly host?: string;
+    readonly port?: number;
+    readonly database?: string;
+    readonly user?: string;
+    readonly password?: string;
+    readonly queryTimeout: number;
+    readonly keepAlive: boolean;
+    readonly keepAliveInitialDelayMillis: number;
+    readonly minPool: number;
+    readonly maxPool: number;
+    readonly searchPath?: string;
+    readonly charset?: string;
+}
+/** Apply the C3 defaults (queryTimeout=0, keepAlive=false, minPool=0, maxPool=10). */
+export declare function resolveConnectionConfig(config?: ConnectionConfig): ResolvedConnectionConfig;
+/**
+ * The SESSION statements a connection must run at checkout to honor a {@link ResolvedConnectionConfig}
+ * (issued once per acquired connection, in order). This is the per-dialect mapping the port agents
+ * mirror; it is pure (no connection contact) so it is testable in isolation:
+ *
+ *   - **statement timeout** (`queryTimeout` > 0): PG `SET statement_timeout = <ms>`; MySQL
+ *     `SET SESSION max_execution_time = <ms>` (both server-side, ms).
+ *   - **searchPath**: PG `SET search_path TO <path>`; MySQL has no schema search path ⇒ ignored.
+ *   - **charset**: MySQL `SET NAMES <charset>`; PG `SET client_encoding TO <charset>`.
+ *
+ * A key with no value emits nothing (⇒ empty array for an all-default config ⇒ the session is
+ * untouched, backward-compatible). sqlite has no server session ⇒ empty.
+ */
+export declare function sessionStatements(config: ResolvedConnectionConfig): readonly string[];
+/**
+ * A reader/writer pool PAIR for ONE named connection (C1). `reader` serves read-intent statements;
+ * `writer` serves write-intent statements, `withWriter` reads, and writer-sticky reads. When a
+ * connection has no separate replica, `reader === writer` is the SAME pool object — reader/writer
+ * routing then always lands on that one pool (the single-pool backward-compat case).
+ */
+export interface ReaderWriterPools {
+    readonly reader: AsyncConnectionPool;
+    readonly writer: AsyncConnectionPool;
+}
+/** Build a {@link ReaderWriterPools} where reader === writer (single-pool, backward-compat). */
+export declare function singlePoolPair(pool: AsyncConnectionPool): ReaderWriterPools;
+/** Build a {@link ReaderWriterPools} from a distinct reader + writer pool (reader/writer separation). */
+export declare function readerWriterPair(reader: AsyncConnectionPool, writer: AsyncConnectionPool): ReaderWriterPools;
+/** The reserved name of the DEFAULT (unnamed) connection. An `intent.db` of `undefined` uses this. */
+export declare const DEFAULT_CONNECTION = "default";
+/**
+ * The multi-DB connection registry (C2): a map from a connection NAME → its {@link ReaderWriterPools}.
+ * `connectionFor(intent)` selects the pair by `intent.db` (the connection name the bundle/model
+ * metadata carries — decorator-free, from config + metadata; decorator wiring is Phase F), falling
+ * back to {@link DEFAULT_CONNECTION} when unnamed. Selecting a name that was never registered is a
+ * LOUD error (a real wiring bug — never a silent default fallback, which would run a query on the
+ * wrong DB; mirrors the V0 cross-DB relation registry's loud-fail policy).
+ *
+ * A single-DB deployment registers exactly one connection under {@link DEFAULT_CONNECTION} with
+ * `reader === writer` ⇒ every intent routes to that one pool ⇒ byte-identical to Phase A/B.
+ */
+export declare class ConnectionRegistry {
+    /** name → reader/writer pools. */
+    private readonly connections;
+    constructor(connections: ReadonlyMap<string, ReaderWriterPools>);
+    /**
+     * Build a registry from ONE pool as the default connection (reader === writer). This is the
+     * backward-compat path: {@link import('./exec-context').PooledAsyncContext} built from a single
+     * pool wraps it here so its `connectionFor` routes every intent to that one pool.
+     */
+    static singleDefault(pool: AsyncConnectionPool): ConnectionRegistry;
+    /** Fluent builder: start from a default connection's pools, then `.add(name, pools)` more. */
+    static fromDefault(pools: ReaderWriterPools): ConnectionRegistryBuilder;
+    /** The reader/writer pair for `name` (or {@link DEFAULT_CONNECTION} when `undefined`). Loud on a missing name. */
+    pairFor(name: string | undefined): ReaderWriterPools;
+    /** The registered connection names (for diagnostics / `closeAllPools`). */
+    names(): readonly string[];
+    /** Every DISTINCT pool object across all connections (a shared reader===writer counts once). */
+    distinctPools(): readonly AsyncConnectionPool[];
+}
+/** Incremental {@link ConnectionRegistry} builder (name → pools). */
+export declare class ConnectionRegistryBuilder {
+    private readonly connections;
+    /** Register `name` → its reader/writer pools (chainable). Re-adding a name overwrites it. */
+    add(name: string, pools: ReaderWriterPools): this;
+    /** Finalize into an immutable {@link ConnectionRegistry}. */
+    build(): ConnectionRegistry;
+}
+/** True if the current async scope is inside a {@link withWriter} scope. */
+export declare function inWriterScope(): boolean;
+/**
+ * Run `fn` with reads pinned to the WRITER pool (mirror v1 `DBModel.withWriter`): every read `fn`
+ * issues resolves the writer pool (read-your-writes without replication lag), and — because this ALSO
+ * enters a {@link import('./tx-options').withReadOnly} scope — ANY write inside `fn` throws
+ * {@link import('../types').WriteInReadOnlyContextError}. Nested `withWriter` is idempotent (already
+ * in a writer scope ⇒ just run `fn`). Inside a transaction the tx-owned connection already wins in
+ * `connectionFor`, so a `withWriter` there is a no-op on routing (matches v1 :2941).
+ *
+ * @param fn the read-your-writes scope body.
+ */
+export declare function withWriter<R>(fn: () => Promise<R>): Promise<R>;
+/**
+ * A writer-sticky CLOCK (C1, read-your-writes; v1 `_shouldUseWriterSticky` :344 + `_lastTransactionTime`).
+ * After a transaction (or a bare write) COMMITs, reads within `stickyDurationMs` route to the WRITER
+ * pool so a just-committed row is visible despite reader-replica lag. The ctx owns ONE clock instance;
+ * the tx runtime `.mark()`s it on every successful write/commit; `connectionFor` reads `.isSticky()`.
+ *
+ * `useWriterAfterTransaction=false` disables it entirely (`.isSticky()` always false). A single-pool
+ * deployment (reader === writer) is unaffected by stickiness — the diverted pool is the same object.
+ */
+export declare class WriterStickyClock {
+    private lastWriteAt;
+    private readonly enabled;
+    private readonly stickyDurationMs;
+    /** Injectable clock (tests advance it); defaults to `Date.now`. */
+    private readonly now;
+    constructor(opts?: {
+        useWriterAfterTransaction?: boolean;
+        writerStickyDuration?: number;
+        now?: () => number;
+    });
+    /** Record that a write/commit just happened (the tx runtime calls this on success). */
+    mark(): void;
+    /** Is a read currently sticky-to-writer (within `writerStickyDuration` of the last write)? */
+    isSticky(): boolean;
+    /** Reset the clock (e.g. between tests / on `closeAllPools`). */
+    reset(): void;
+}
+/**
+ * The routing configuration a {@link import('./exec-context').PooledAsyncContext} carries to complete
+ * its `connectionFor(intent)` resolution (steps 2-4): the multi-DB {@link ConnectionRegistry}, the
+ * {@link WriterStickyClock}, and the resolved per-connection {@link ResolvedConnectionConfig} (for the
+ * session statements the pool applies). Absent ⇒ the ctx falls back to its single default pool with
+ * an always-false sticky clock — the byte-identical Phase A/B path.
+ */
+export interface RoutingConfig {
+    readonly registry: ConnectionRegistry;
+    readonly sticky: WriterStickyClock;
+}
+/**
+ * Resolve WHICH pool serves a statement given its {@link import('./exec-context').StatementIntent}
+ * and the routing config — the completion of `connectionFor`'s steps 2-4 (step 1, the tx-pin, is
+ * handled by the ctx BEFORE calling this, since only the ctx holds the ALS pin). The order:
+ *
+ *   1. **named-DB** (`intent.db`) selects the {@link ReaderWriterPools} pair (loud on unknown name).
+ *   2. within that pair: a WRITE ⇒ the writer pool.
+ *   3. a READ in a {@link withWriter} scope OR within writer-sticky ⇒ the writer pool (read-your-writes).
+ *   4. otherwise a READ ⇒ the reader pool.
+ *
+ * Single-pool (reader === writer) ⇒ every branch returns the same pool (backward-compat).
+ */
+export declare function resolvePool(intent: {
+    readonly write: boolean;
+    readonly db?: string;
+}, routing: RoutingConfig): AsyncConnectionPool;
+/**
+ * The RESET statements that undo {@link sessionStatements} on release (per dialect), so a session
+ * knob (`statement_timeout` / `search_path` / `client_encoding` / `max_execution_time` / charset)
+ * set for THIS configured connection does NOT leak to the next caller that draws the SAME underlying
+ * pooled connection — pg/mysql2 do NOT auto-reset session state on release. `RESET`/`SET … DEFAULT`
+ * restores the server default. Only the knobs `config` actually set are reset (an all-default config
+ * ⇒ nothing to reset).
+ */
+export declare function sessionResetStatements(config: ResolvedConnectionConfig): readonly string[];
+/**
+ * Wrap an {@link AsyncConnectionPool} so every acquired connection first runs the
+ * {@link sessionStatements} for `config` (statement timeout / search_path / charset) and, on release,
+ * runs {@link sessionResetStatements} to restore the server defaults (so a pooled connection never
+ * leaks THIS config's session state to the next caller — pg/mysql2 don't auto-reset on release). A
+ * config with no session knobs (all defaults) ⇒ ZERO extra statements ⇒ the wrapper is a transparent
+ * passthrough (backward-compat). This is where C3's `queryTimeout`/`searchPath`/`charset` become REAL
+ * per-server effects — the acquired connection carries them for the statement(s) that run on it.
+ *
+ * If a session statement itself fails (e.g. an invalid search_path), the connection is released back
+ * as DESTROYED so a mis-configured connection never re-enters the pool. On release, if a statement
+ * ERRORED (the connection is possibly aborted — e.g. a fired statement timeout), the reset is SKIPPED
+ * and the connection is DESTROYED (a poisoned connection must not re-enter the pool anyway).
+ */
+export declare function configuredPool(pool: AsyncConnectionPool, config: ResolvedConnectionConfig): AsyncConnectionPool;
+/** A pool CLOSER — closes a pool's underlying connections (pg `pool.end()` / mysql2 `pool.end()`). */
+export type PoolCloser = () => Promise<void>;
+/**
+ * A driver's pool factory: BUILD a pool from a {@link ResolvedConnectionConfig}, returning the
+ * {@link AsyncConnectionPool} seam adapter plus a {@link PoolCloser}. This is where the CONSTRUCTION
+ * knobs — pool sizing (`minPool`/`maxPool`) + `keepAlive`/`keepAliveInitialDelayMillis` — reach the
+ * real driver (`new pg.Pool({ max, keepAlive, … })` / `mysql2.createPool({ connectionLimit, … })`),
+ * because those are pool-CONSTRUCTION options a pre-built pool can no longer accept.
+ *
+ * `buildRoutingConfig` OWNS the call to this factory with the RESOLVED config, so the configured
+ * sizing/keepAlive is the SOLE source of the pool's cap — there is no second raw `new Pool({max})`
+ * path. `role` lets a factory build a distinct replica pool for the reader vs. the writer (e.g. a
+ * different host) while sharing the same sizing config; a factory that returns the SAME pool for both
+ * roles collapses to single-pool (reader === writer).
+ *
+ * The module stays driver-AGNOSTIC: the factory is supplied by the peer-dep-owning caller (this file
+ * imports no driver). The pool-executor adapters (`makesql/pool-executor.ts`) provide the concrete
+ * pg/mysql2 factories; the port agents (#88-91) supply their language's equivalent — the SAME shape.
+ */
+export type PoolFactory = (config: ResolvedConnectionConfig, role: 'reader' | 'writer') => {
+    pool: AsyncConnectionPool;
+    close: PoolCloser;
+};
+/**
+ * One connection's inputs to {@link buildRoutingConfig}: its NAME (default when absent), its
+ * {@link ConnectionConfig} (connection params + sizing + keepAlive + session knobs), and a
+ * {@link PoolFactory} that `buildRoutingConfig` CALLS with the resolved config to construct the
+ * pool(s) — so sizing/keepAlive are applied at construction and the config is the sole cap source.
+ *
+ * `separateWriter: true` asks the factory for a DISTINCT writer pool (reader/writer replica split);
+ * otherwise the factory's reader pool is reused as the writer (single-pool, reader === writer).
+ */
+export interface ConnectionSetup {
+    readonly name?: string;
+    readonly config?: ConnectionConfig;
+    /** The driver pool factory (built by `buildRoutingConfig` with the resolved config — sizing/keepAlive land here). */
+    readonly poolFactory: PoolFactory;
+    /** Build a distinct writer pool via the factory (replica split). Default false ⇒ reader === writer. */
+    readonly separateWriter?: boolean;
+}
+/**
+ * The C3 `setConfig` result: the {@link RoutingConfig} a {@link import('./exec-context').PooledAsyncContext}
+ * runs on, plus a `close()` that shuts every constructed pool ({@link closeAllPools}). Build it from
+ * one or more {@link ConnectionSetup}s (the one named `default`, or the first unnamed, is the default
+ * connection).
+ *
+ * For each setup: resolve the config, CALL its {@link PoolFactory} to construct the pool(s) — so
+ * `minPool`/`maxPool`/`keepAlive`/`keepAliveInitialDelayMillis` are applied at `new Pool()` /
+ * `createPool()` time (the config is the SOLE source of the cap) — then wrap each pool with
+ * {@link configuredPool} so the SESSION knobs (queryTimeout/searchPath/charset) apply on checkout.
+ */
+export declare function buildRoutingConfig(setups: readonly ConnectionSetup[], stickyOpts?: {
+    useWriterAfterTransaction?: boolean;
+    writerStickyDuration?: number;
+}): {
+    routing: RoutingConfig;
+    close: PoolCloser;
+};
+//# sourceMappingURL=connection-routing.d.ts.map

package/dist/scp/connection-routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-routing.d.ts","sourceRoot":"","sources":["../../src/scp/connection-routing.ts"],"names":[],"mappings":"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"}