@crvouga/mockingbird-service-postgres 1.6.0 → 1.7.0

package/dist/wire/cluster.d.ts

@@ -1,4 +1,5 @@
 import { Database } from "../api/database.js";
+import type { Snapshot } from "../api/snapshot.js";
 /**
  * What every connection of one server shares: the engine, and the coordination the engine
  * (single-session, synchronous) does not do itself.
@@ -31,6 +32,8 @@ export declare class Cluster {
     /** The initial database, retained for the server's backwards-compatible public handle. */
     get db(): Database;
     databaseNames(): string[];
+    snapshotAll(): Map<string, Snapshot>;
+    restoreAll(points: ReadonlyMap<string, Snapshot>): void;
     getDatabase(name: string): Database | undefined;
     requireDatabase(name: string): Database;
     createDatabase(name: string, template?: string): void;

package/dist/wire/fleet.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The single source of time for a service.
+ *
+ * Every timestamp a mock writes reads from here, so a suite moves time instead of
+ * sleeping: appointment windows, result delays and expiries become reachable in
+ * milliseconds. A frozen clock also makes timestamps reproducible from a seed.
+ */
+type ClockState = {
+    /** Current epoch milliseconds. */
+    now: number;
+    /** True while time does not advance on its own. */
+    frozen: boolean;
+    /** Milliseconds this clock adds to its underlying source. */
+    offsetMs: number;
+};
+type Clock = {
+    now(): number;
+    /** Pin the clock to an exact instant, keeping it frozen if it already was. */
+    set(epochMs: number): void;
+    /** Move the clock forward, or back with a negative delta. */
+    advance(deltaMs: number): void;
+    /** Stop time at the current instant. */
+    freeze(): void;
+    /** Resume from the current instant. */
+    unfreeze(): void;
+    /** Drop back to the underlying source, live. */
+    reset(): void;
+    state(): ClockState;
+};
+
+type FleetDiagnostics = {
+    activeRequests: number;
+    activeConnections: number;
+    blockedCommands: number;
+    pendingJobs: number;
+    activeJobs?: number;
+    pendingWebhooks: number;
+    unmatchedRequests: number;
+};
+/** Protocol packages own their state, listeners, credentials and namespace selection. */
+type FleetChild = {
+    protocol: "http" | "postgres" | "redis";
+    url: string;
+    connection?: string;
+    connections?: Record<string, string>;
+    healthUrl?: string;
+    adminUrl?: string;
+    namespaces: Record<string, unknown>;
+    ready(): Promise<boolean>;
+    close(): Promise<void>;
+    /** Fence new work synchronously; diagnostics must also account for work already in flight. */
+    lock(namespace: string): () => void;
+    diagnostics(namespace: string): FleetDiagnostics;
+    checkpoint(namespace: string): Promise<unknown>;
+    restore(namespace: string, checkpoint: unknown): Promise<void>;
+    reset(namespace: string): Promise<void>;
+    clock(namespace: string): Clock;
+    settle?(namespace: string): Promise<void>;
+};
+
+/** A service entry in `mockingbird.json`. */
+type ConfigService = {
+    protocol?: "http" | "postgres" | "redis";
+    port?: number;
+    host?: string;
+    adminKey?: string;
+    seed?: string;
+    password?: string;
+    user?: string;
+    database?: string;
+    /** Protocol namespace selectors: database names for Postgres, logical DB indexes for Redis. */
+    namespaces?: Record<string, string | number>;
+    /** Service-specific serve flags, by long name: `{ "webhook-url": "…" }`. */
+    options?: Record<string, string | boolean>;
+};
+
+/** Separate database listeners make the protocol namespace explicit in discovery. */
+declare function startProtocol(entry: ConfigService): Promise<FleetChild>;
+
+export { startProtocol };

package/dist/wire/index.d.ts

@@ -55,6 +55,8 @@ export type ServeOptions = {
      * SQLSTATE `3D000`. Set from `url` when the path is non-empty. Unset accepts any name.
      */
     databaseName?: string;
+    /** Accept other databases in this listener's catalog while retaining its default URL. */
+    allowDatabaseSelection?: boolean;
     /** Role shown in `connectionString`. A URI's username fills this. Default `postgres`. */
     user?: string;
 };
@@ -77,8 +79,12 @@ export type PostgresServer = {
     readonly connections: number;
     /** Arm a fault preset for the next statement / connection (see {@link ServerFaults}). */
     fault(fault: ServerFaults): void;
+    clearFaults(): void;
     /** Freeze the live state (the admin `snapshot()` control). */
     snapshot(name?: string): Snapshot;
+    snapshotAll(): Map<string, Snapshot>;
+    restoreAll(points: ReadonlyMap<string, Snapshot>): void;
+    faultState(): ServerFaults;
     /** Stop listening and close every connection. */
     close(): Promise<void>;
 };

package/dist/wire/index.js

@@ -23733,6 +23733,16 @@ var Cluster = class {
   databaseNames() {
     return [...this.databases.keys()].sort();
   }
+  snapshotAll() {
+    return new Map([...this.databases].map(([name, db]) => [name, db.snapshot()]));
+  }
+  restoreAll(points) {
+    if (this.sessions.size > 0) throw new Error("cannot restore a catalog with active sessions");
+    if (!points.has(this.defaultDatabaseName)) throw new Error("snapshot lacks default database");
+    for (const db of this.databases.values()) db.close();
+    this.databases.clear();
+    for (const [name, point] of points) this.installDatabase(name, point.open());
+  }
   getDatabase(name) {
     return this.databases.get(name);
   }
@@ -23745,7 +23755,7 @@ var Cluster = class {
     if (this.databases.has(name)) {
       throw new PostgresError("duplicate_object", `database "${name}" already exists`, "42P04");
     }
-    const db = template === void 0 ? new Database() : this.requireTemplate(template).snapshot().open();
+    const db = template === void 0 ? new Database({ now: this.db.now, seed: this.db.seed }) : this.requireTemplate(template).snapshot().open();
     this.installDatabase(name, db);
   }
   dropDatabase(name, requester) {
@@ -25469,7 +25479,7 @@ var serve = (input = {}) => {
       serverVersion: options.serverVersion ?? "18.3",
       parameters: options.parameters ?? {},
       faults,
-      ...options.databaseName !== void 0 ? { database: options.databaseName } : {},
+      ...options.databaseName !== void 0 && !options.allowDatabaseSelection ? { database: options.databaseName } : {},
       ...options.onLog ? { onLog: options.onLog } : {}
     });
     connections.add(connection);
@@ -25487,7 +25497,9 @@ var serve = (input = {}) => {
         port,
         host,
         connectionString: `postgres://${auth}${host}:${port}/${encodeURIComponent(name)}`,
-        database,
+        get database() {
+          return cluster.db;
+        },
         databaseNames() {
           return cluster.databaseNames();
         },
@@ -25501,6 +25513,14 @@ var serve = (input = {}) => {
         fault(next) {
           Object.assign(faults, next);
         },
+        clearFaults() {
+          for (const key of Object.keys(faults)) delete faults[key];
+        },
+        faultState() {
+          return structuredClone(faults);
+        },
+        snapshotAll: () => cluster.snapshotAll(),
+        restoreAll: (points) => cluster.restoreAll(points),
         snapshot(databaseName = initialName) {
           return cluster.requireDatabase(databaseName).snapshot();
         },