@crvouga/mockingbird-service-postgres 1.5.0 → 1.6.0

package/dist/wire/cluster.d.ts

@@ -1,13 +1,11 @@
-import type { Database } from "../api/database.js";
+import { Database } from "../api/database.js";
 /**
  * What every connection of one server shares: the engine, and the coordination the engine
  * (single-session, synchronous) does not do itself.
  *
- * - The **turn**: the engine holds one transaction at a time, so a connection inside an
- *   explicit transaction block holds the turn until it commits or rolls back, and every other
- *   connection's statement waits. A statement outside a block takes the turn for itself only.
- *   Uncommitted rows are therefore never visible to another connection (read committed holds),
- *   at the cost of running transaction blocks one at a time.
+ * - The **turn** serializes individual synchronous engine calls. Explicit transactions use
+ *   per-session copy-on-write workspaces in the connection, so the turn is released after every
+ *   statement and unrelated sessions keep progressing.
  * - **Advisory locks** per session, with waiters woken in order, and deadlock detection
  *   between a lock and the turn (`40P01`).
  * - **LISTEN / NOTIFY** fan-out, delivered when a listening connection is idle.
@@ -15,7 +13,7 @@ import type { Database } from "../api/database.js";
  *   (`pg_backend_pid`, `pg_advisory_lock`, `pg_notify`, …) know whom they serve.
  */
 export declare class Cluster {
-    readonly db: Database;
+    readonly defaultDatabaseName: string;
     turnHolder: Session | null;
     private readonly turnQueue;
     readonly locks: Map<string, {
@@ -28,7 +26,19 @@ export declare class Cluster {
     readonly sessions: Map<number, Session>;
     current: Session | null;
     private nextPid;
-    constructor(db: Database);
+    private readonly databases;
+    constructor(db: Database, defaultDatabaseName?: string);
+    /** The initial database, retained for the server's backwards-compatible public handle. */
+    get db(): Database;
+    databaseNames(): string[];
+    getDatabase(name: string): Database | undefined;
+    requireDatabase(name: string): Database;
+    createDatabase(name: string, template?: string): void;
+    dropDatabase(name: string, requester: Session): void;
+    renameDatabase(from: string, to: string, requester: Session): void;
+    private requireTemplate;
+    private activeConnections;
+    private installDatabase;
     newPid(): number;
     /** Wait until this session may execute: at once when nobody holds the turn, or it does. */
     acquireTurn(session: Session): Promise<void>;
@@ -59,6 +69,8 @@ export declare class LockWait extends Error {
 /** What the cluster needs from a connection. */
 export interface Session {
     readonly pid: number;
+    database: Database;
+    databaseName: string;
     waitingForTurn: Waiter | null;
     waitingForLock: string | null;
     /** NOTIFYs issued inside the current transaction block, sent at commit. */

package/dist/wire/connection.d.ts

@@ -1,4 +1,5 @@
 import type { Socket } from "node:net";
+import type { Database } from "../api/database.js";
 import { type Cluster, type Session } from "./cluster.js";
 export type ServerFaults = {
     /** Destroy the socket of the next connection that runs a statement inside a transaction block. */
@@ -43,6 +44,8 @@ export declare class Connection implements Session {
         channel: string;
         payload: string;
     }[];
+    database: Database;
+    databaseName: string;
     private readonly frames;
     private readonly inbox;
     private pumping;
@@ -59,6 +62,10 @@ export declare class Connection implements Session {
     private readonly prepared;
     private readonly portals;
     private readonly notifications;
+    private copyIn;
+    private copyDrain;
+    /** Successful writes in this session's READ COMMITTED transaction workspace. */
+    private transaction;
     private closed;
     constructor(socket: Socket, cluster: Cluster, options: ConnectionOptions);
     private receive;
@@ -88,12 +95,29 @@ export declare class Connection implements Session {
     private waitForLock;
     /** The engine call itself: statement-atomic, and transaction control handled as the server sees it. */
     private runStatement;
-    /** Release the turn and transaction-scoped locks once no block is open; deliver NOTIFYs at commit. */
+    /** Release the statement turn; transaction-scoped locks live until COMMIT / ROLLBACK. */
     private afterStatement;
+    private transactionControl;
+    private findSavepoint;
+    /** Rebase this transaction's successful writes onto the latest committed state. */
+    private openWorkspace;
+    private replay;
+    private runQuery;
+    private lockRows;
+    private rowLockKey;
     private flushNotifies;
+    private executeClusterDdl;
     private listen;
     private unlisten;
     private query;
+    private copyStatement;
+    private copyColumnCount;
+    private handleCopyIn;
+    private beginCopyIn;
+    private finishCopyIn;
+    private flushCopyRecords;
+    private abortCopyIn;
+    private sendCopyOut;
     private sendOutcome;
     private columnFormats;
     private fields;

package/dist/wire/index.d.ts

@@ -67,6 +67,10 @@ export type PostgresServer = {
     readonly connectionString: string;
     /** The shared engine, for seeding, snapshotting or asserting from the test process. */
     readonly database: Database;
+    /** Names in the cluster catalog, in deterministic order. */
+    databaseNames(): readonly string[];
+    /** Resolve a named database, or throw SQLSTATE `3D000`. */
+    getDatabase(name: string): Database;
     /** The underlying `net.Server`. */
     readonly server: Server;
     /** Open connections right now. */
@@ -74,7 +78,7 @@ export type PostgresServer = {
     /** Arm a fault preset for the next statement / connection (see {@link ServerFaults}). */
     fault(fault: ServerFaults): void;
     /** Freeze the live state (the admin `snapshot()` control). */
-    snapshot(): Snapshot;
+    snapshot(name?: string): Snapshot;
     /** Stop listening and close every connection. */
     close(): Promise<void>;
 };