@hexaijs/postgres 0.4.0 → 0.5.1

package/dist/test.js

@@ -1,259 +1,696 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresUnitOfWorkForTesting = void 0;
-exports.createTestContext = createTestContext;
-const node_async_hooks_1 = require("node:async_hooks");
-const pg_1 = require("pg");
-const core_1 = require("@hexaijs/core");
-const helpers_1 = require("./helpers");
-const config_1 = require("./config");
-const run_hexai_migrations_1 = require("./run-hexai-migrations");
-function createTestContext(dbUrl) {
-    const config = typeof dbUrl === "string" ? config_1.PostgresConfig.fromUrl(dbUrl) : dbUrl;
-    const dbName = config.database;
-    const databaseManager = new helpers_1.DatabaseManager(config.withDatabase("postgres"));
-    const tableManager = new helpers_1.TableManager(config);
-    async function setup() {
-        try {
-            await databaseManager.dropDatabase(dbName);
-        }
-        catch (e) {
-            if ((0, helpers_1.isDatabaseError)(e) && e.code === "3D000") {
-                // ignore
-            }
-            else {
-                throw e;
-            }
-        }
-        await databaseManager.createDatabase(dbName);
-        await (0, run_hexai_migrations_1.runHexaiMigrations)(config);
-    }
-    async function teardown() {
-        await tableManager.close();
-        await databaseManager.dropDatabase(dbName);
-        await databaseManager.close();
-    }
+import { AsyncLocalStorage } from 'async_hooks';
+import * as pg from 'pg';
+import { Client } from 'pg';
+import { Propagation } from '@hexaijs/core';
+import * as fs2 from 'fs/promises';
+import * as path2 from 'path';
+import path2__default from 'path';
+import { fileURLToPath } from 'url';
+import runner from 'node-pg-migrate';
+
+// src/test.ts
+
+// src/config/postgres-config.ts
+var PostgresConfig = class _PostgresConfig {
+  host;
+  database;
+  user;
+  port;
+  password;
+  pool;
+  constructor(config) {
+    this.database = config.database;
+    this.password = config.password;
+    this.host = config.host ?? "localhost";
+    this.user = config.user ?? "postgres";
+    this.port = config.port ?? 5432;
+    this.pool = config.pool;
+  }
+  static fromUrl(value) {
+    return new _PostgresConfig(_PostgresConfig.parseUrl(value));
+  }
+  /**
+   * Creates a PostgresConfig from environment variables.
+   *
+   * @param prefix - Environment variable prefix
+   * @param options - Loading options (mode: "url" | "fields")
+   * @throws Error if required environment variables are not set
+   *
+   * @example
+   * ```typescript
+   * // URL mode (default): reads ASSIGNMENT_DB_URL
+   * const config = PostgresConfig.fromEnv("ASSIGNMENT_DB");
+   *
+   * // Fields mode: reads POSTGRES_HOST, POSTGRES_PORT, POSTGRES_DATABASE, POSTGRES_USER, POSTGRES_PASSWORD
+   * const config = PostgresConfig.fromEnv("POSTGRES", { mode: "fields" });
+   * ```
+   */
+  static fromEnv(prefix, options) {
+    const mode = options?.mode ?? "url";
+    if (mode === "url") {
+      const envKey = `${prefix}_URL`;
+      const url = process.env[envKey];
+      if (!url) {
+        throw new Error(`Environment variable ${envKey} is not set`);
+      }
+      return _PostgresConfig.fromUrl(url);
+    }
+    const database = process.env[`${prefix}_DATABASE`];
+    if (!database) {
+      throw new Error(
+        `Environment variable ${prefix}_DATABASE is not set`
+      );
+    }
+    return new _PostgresConfig({
+      database,
+      host: process.env[`${prefix}_HOST`],
+      port: process.env[`${prefix}_PORT`] ? parseInt(process.env[`${prefix}_PORT`]) : void 0,
+      user: process.env[`${prefix}_USER`],
+      password: process.env[`${prefix}_PASSWORD`]
+    });
+  }
+  static parseUrl(value) {
+    const regex = /postgres(ql)?:\/\/(?<user>[^:/]+)(:(?<password>[^@]+))?@(?<host>[^:/]+)(:(?<port>\d+))?\/(?<database>.+)/;
+    const matches = value.match(regex);
+    if (!matches?.groups) {
+      throw new Error(`Invalid postgres url: ${value}`);
+    }
+    const { user, password, host, port, database } = matches.groups;
     return {
-        client: tableManager.getClient(),
-        newClient: () => new pg_1.Client(dbUrl),
-        tableManager,
-        setup,
-        teardown,
+      host,
+      database,
+      user,
+      port: port ? parseInt(port) : 5432,
+      password
     };
+  }
+  withDatabase(database) {
+    return new _PostgresConfig({
+      host: this.host,
+      database,
+      user: this.user,
+      port: this.port,
+      password: this.password,
+      pool: this.pool
+    });
+  }
+  withUser(user) {
+    return new _PostgresConfig({
+      host: this.host,
+      database: this.database,
+      user,
+      port: this.port,
+      password: this.password,
+      pool: this.pool
+    });
+  }
+  withPassword(password) {
+    return new _PostgresConfig({
+      host: this.host,
+      database: this.database,
+      user: this.user,
+      port: this.port,
+      password,
+      pool: this.pool
+    });
+  }
+  withHost(host) {
+    return new _PostgresConfig({
+      host,
+      database: this.database,
+      user: this.user,
+      port: this.port,
+      password: this.password,
+      pool: this.pool
+    });
+  }
+  withPort(port) {
+    return new _PostgresConfig({
+      host: this.host,
+      database: this.database,
+      user: this.user,
+      port,
+      password: this.password,
+      pool: this.pool
+    });
+  }
+  withPoolSize(size) {
+    return new _PostgresConfig({
+      host: this.host,
+      database: this.database,
+      user: this.user,
+      port: this.port,
+      password: this.password,
+      pool: { ...this.pool, size }
+    });
+  }
+  withConnectionTimeout(connectionTimeout) {
+    return new _PostgresConfig({
+      host: this.host,
+      database: this.database,
+      user: this.user,
+      port: this.port,
+      password: this.password,
+      pool: { ...this.pool, connectionTimeout }
+    });
+  }
+  withIdleTimeout(idleTimeout) {
+    return new _PostgresConfig({
+      host: this.host,
+      database: this.database,
+      user: this.user,
+      port: this.port,
+      password: this.password,
+      pool: { ...this.pool, idleTimeout }
+    });
+  }
+  toString() {
+    let url = `postgres://${this.user}`;
+    if (this.password) {
+      url += `:${this.password}`;
+    }
+    url += `@${this.host}:${this.port}/${this.database}`;
+    const queryParams = [];
+    if (this.pool?.size !== void 0) {
+      queryParams.push(`pool_size=${this.pool.size}`);
+    }
+    if (this.pool?.connectionTimeout !== void 0) {
+      queryParams.push(
+        `connection_timeout=${this.pool.connectionTimeout}`
+      );
+    }
+    if (this.pool?.idleTimeout !== void 0) {
+      queryParams.push(`idle_timeout=${this.pool.idleTimeout}`);
+    }
+    if (queryParams.length > 0) {
+      url += `?${queryParams.join("&")}`;
+    }
+    return url;
+  }
+};
+
+// src/helpers.ts
+var ClientWrapper = class {
+  client;
+  getClient() {
+    return this.client;
+  }
+  constructor(urlOrClient) {
+    if (urlOrClient instanceof PostgresConfig || typeof urlOrClient === "string") {
+      this.client = new pg.Client({
+        connectionString: urlOrClient.toString()
+      });
+    } else {
+      this.client = urlOrClient;
+    }
+  }
+  async withClient(work) {
+    await ensureConnection(this.client);
+    return work(this.client);
+  }
+  async query(query, params) {
+    const result = await this.withClient(
+      (client) => client.query(query, params)
+    );
+    return result.rows;
+  }
+  async close() {
+    await this.client.end();
+  }
+};
+var DatabaseManager = class extends ClientWrapper {
+  async createDatabase(name) {
+    const exists = await this.query(
+      `SELECT 1 FROM pg_database WHERE datname = '${name}'`
+    );
+    if (exists.length === 0) {
+      await this.client.query(`CREATE DATABASE ${name}`);
+    }
+  }
+  async dropDatabase(name) {
+    await this.query(`DROP DATABASE IF EXISTS ${name}`);
+  }
+};
+var TableManager = class extends ClientWrapper {
+  async getTableSchema(tableName) {
+    const result = await this.query(`
+            SELECT
+                column_name AS column,
+                data_type AS type
+            FROM information_schema.columns
+            WHERE table_name = '${tableName}';
+        `);
+    return result.map((row) => ({
+      column: row.column,
+      type: row.type
+    }));
+  }
+  async tableExists(tableName) {
+    const result = await this.query(`
+            SELECT
+                table_name
+            FROM information_schema.tables
+            WHERE table_name = '${tableName}';
+        `);
+    return result.length > 0;
+  }
+  async createTable(name, columns) {
+    if (await this.tableExists(name)) {
+      return;
+    }
+    const query = `
+            CREATE TABLE ${name} (
+                ${columns.map((column) => `${column.name} ${column.property}`).join(", ")}
+            );
+        `;
+    await this.query(query);
+  }
+  async dropTable(name) {
+    await this.query(`DROP TABLE IF EXISTS "${name}";`);
+  }
+  async truncateTable(name) {
+    await this.query(`TRUNCATE TABLE "${name}" RESTART IDENTITY CASCADE;`);
+  }
+  async truncateAllTables() {
+    const tables = await this.getTableNames();
+    await Promise.all(tables.map((table) => this.truncateTable(table)));
+  }
+  async dropAllTables() {
+    const tables = await this.getTableNames();
+    await Promise.all(tables.map((table) => this.dropTable(table)));
+  }
+  async getTableNames() {
+    const result = await this.query(`
+            SELECT table_name
+            FROM information_schema.tables
+            WHERE table_schema = 'public'
+            AND table_type = 'BASE TABLE';
+        `);
+    return result.map((row) => row.table_name);
+  }
+};
+async function ensureConnection(client) {
+  try {
+    await client.connect();
+  } catch (e) {
+    if (e.message.includes("already")) ; else {
+      throw e;
+    }
+  }
 }
-class PostgresUnitOfWorkForTesting {
-    client;
-    executorStorage = new node_async_hooks_1.AsyncLocalStorage();
-    constructor(client) {
-        this.client = client;
-    }
-    getClient() {
-        const executor = this.getCurrentExecutor();
-        if (!executor) {
-            throw new Error("Unit of work not started");
-        }
-        return this.client;
-    }
-    async withClient(fn) {
-        return fn(this.client);
-    }
-    async wrap(fn, options = {}) {
-        const resolvedOptions = this.resolveOptions(options);
-        const executor = this.resolveExecutor(resolvedOptions);
-        return this.executeInContext(executor, (exec) => exec.execute(fn, resolvedOptions));
-    }
-    getCurrentExecutor() {
-        return this.executorStorage.getStore() ?? null;
-    }
-    resolveOptions(options) {
-        return {
-            propagation: core_1.Propagation.EXISTING,
-            ...options,
-        };
-    }
-    resolveExecutor(options) {
-        if (options.propagation === core_1.Propagation.NEW) {
-            console.warn("[PostgresUnitOfWorkForTesting] Propagation.NEW is not fully supported in testing mode. Using savepoint instead.");
-            return this.createExecutor();
-        }
-        return this.getCurrentExecutor() ?? this.createExecutor();
-    }
-    createExecutor() {
-        return new TestTransactionExecutor(this.client);
-    }
-    executeInContext(executor, callback) {
-        return this.executorStorage.run(executor, () => callback(executor));
-    }
+function isDatabaseError(e) {
+  return e instanceof Error && "code" in e;
 }
-exports.PostgresUnitOfWorkForTesting = PostgresUnitOfWorkForTesting;
-class TestTransactionExecutor {
-    client;
-    initialized = false;
-    closed = false;
-    abortError;
-    nestingDepth = 0;
-    savepointCounter = 0;
-    savepoints = [];
-    savepointName;
-    constructor(client) {
-        this.client = client;
-        this.savepointName = `test_sp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    }
-    async execute(fn, options) {
-        await this.ensureStarted();
-        const executor = this.resolveExecutor(options.propagation);
-        return executor === this
-            ? this.runWithLifecycle(fn)
-            : executor.execute(fn, options);
-    }
-    getClient() {
-        return this.client;
-    }
-    async ensureStarted() {
-        if (this.initialized) {
-            return;
-        }
-        this.initialized = true;
-        await this.client.query(`SAVEPOINT ${this.savepointName}`);
-    }
-    async runWithLifecycle(fn) {
-        try {
-            return await this.executeWithNesting(fn);
-        }
-        catch (e) {
-            this.markAsAborted(e);
-            throw e;
-        }
-        finally {
-            await this.finalizeIfRoot();
-        }
-    }
-    async executeWithNesting(fn) {
-        this.nestingDepth++;
-        try {
-            return await fn(this.client);
-        }
-        finally {
-            this.nestingDepth--;
-        }
-    }
-    markAsAborted(error) {
-        this.abortError = error;
-    }
-    async finalizeIfRoot() {
-        if (this.nestingDepth === 0) {
-            await (this.isAborted() ? this.rollback() : this.commit());
-        }
-    }
-    resolveExecutor(propagation) {
-        if (this.nestingDepth === 0) {
-            return this;
-        }
-        return propagation === core_1.Propagation.NESTED
-            ? this.createSavepoint()
-            : (this.findActiveSavepoint() ?? this);
-    }
-    createSavepoint() {
-        this.savepointCounter++;
-        const savepoint = new TestSavepoint(`${this.savepointName}_nested_${this.savepointCounter}`, this.client, () => this.removeSavepoint());
-        this.savepoints.push(savepoint);
-        return savepoint;
-    }
-    findActiveSavepoint() {
-        for (let i = this.savepoints.length - 1; i >= 0; i--) {
-            if (!this.savepoints[i].isClosed()) {
-                return this.savepoints[i];
-            }
-        }
-    }
-    removeSavepoint() {
-        this.savepoints.pop();
-    }
-    async commit() {
-        if (this.closed) {
-            return;
-        }
-        this.closed = true;
-        await this.client.query(`RELEASE SAVEPOINT ${this.savepointName}`);
-    }
-    async rollback() {
-        if (this.closed) {
-            return;
-        }
-        this.closed = true;
-        await this.client.query(`ROLLBACK TO SAVEPOINT ${this.savepointName}`);
-    }
-    isAborted() {
-        return this.abortError !== undefined && !this.closed;
-    }
+function extractNumericPrefix(filename) {
+  const match = filename.match(/^(\d+)/);
+  return match ? parseInt(match[1], 10) : 0;
 }
-class TestSavepoint {
-    name;
-    client;
-    onClose;
-    initialized = false;
-    closed = false;
-    abortError;
-    nestingDepth = 0;
-    constructor(name, client, onClose) {
-        this.name = name;
-        this.client = client;
-        this.onClose = onClose;
-    }
-    async execute(fn) {
-        await this.ensureStarted();
-        return this.runWithLifecycle(fn);
-    }
-    isClosed() {
-        return this.closed;
-    }
-    async ensureStarted() {
-        if (this.initialized) {
-            return;
-        }
-        this.initialized = true;
-        await this.client.query(`SAVEPOINT ${this.name}`);
-    }
-    async runWithLifecycle(fn) {
-        this.nestingDepth++;
+async function ensureTableCompatibility(client, tableName) {
+  const tableExists = await client.query(
+    `
+        SELECT 1 FROM information_schema.tables
+        WHERE table_name = $1
+    `,
+    [tableName]
+  );
+  if (tableExists.rows.length === 0) return;
+  const hasAppliedAt = await client.query(
+    `
+        SELECT 1 FROM information_schema.columns
+        WHERE table_name = $1 AND column_name = 'applied_at'
+    `,
+    [tableName]
+  );
+  if (hasAppliedAt.rows.length > 0) {
+    await client.query(`
+            ALTER TABLE "${tableName}"
+            RENAME COLUMN applied_at TO run_on
+        `);
+    console.log(`Migrated table ${tableName}: applied_at \u2192 run_on`);
+  }
+}
+async function isSqlMigrationFormat(dir) {
+  try {
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const sqlPath = path2.join(dir, entry.name, "migration.sql");
         try {
-            return await fn(this.client);
+          await fs2.access(sqlPath);
+          return true;
+        } catch {
         }
-        catch (e) {
-            this.markAsAborted(e);
-            throw e;
-        }
-        finally {
-            this.nestingDepth--;
-            await this.finalizeIfRoot();
-        }
-    }
-    markAsAborted(error) {
-        this.abortError = error;
-    }
-    async finalizeIfRoot() {
-        if (this.nestingDepth === 0) {
-            await (this.isAborted() ? this.rollback() : this.commit());
-        }
-    }
-    async commit() {
-        if (this.closed) {
-            return;
-        }
-        this.closed = true;
-        await this.client.query(`RELEASE SAVEPOINT ${this.name}`);
-        this.onClose();
+      }
     }
-    async rollback() {
-        if (this.closed) {
-            return;
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function runSqlMigrations(client, dir, migrationsTable, dryRun) {
+  await client.query(`
+        CREATE TABLE IF NOT EXISTS "${migrationsTable}" (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(255) NOT NULL,
+            run_on TIMESTAMP NOT NULL DEFAULT NOW()
+        )
+    `);
+  const appliedResult = await client.query(
+    `SELECT name FROM "${migrationsTable}" ORDER BY run_on ASC`
+  );
+  const appliedMigrations = new Set(appliedResult.rows.map((r) => r.name));
+  const entries = await fs2.readdir(dir, { withFileTypes: true });
+  const migrationDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name).sort((a, b) => extractNumericPrefix(a) - extractNumericPrefix(b));
+  const migrationsToApply = [];
+  for (const migrationDir of migrationDirs) {
+    if (appliedMigrations.has(migrationDir)) {
+      continue;
+    }
+    const sqlPath = path2.join(dir, migrationDir, "migration.sql");
+    try {
+      const sql = await fs2.readFile(sqlPath, "utf-8");
+      migrationsToApply.push({ name: migrationDir, sql });
+    } catch {
+    }
+  }
+  if (migrationsToApply.length === 0) {
+    console.log("No migrations to run!");
+    return;
+  }
+  console.log(`> Migrating files:`);
+  for (const migration of migrationsToApply) {
+    console.log(`> - ${migration.name}`);
+  }
+  if (dryRun) {
+    console.log("Dry run - no migrations applied");
+    return;
+  }
+  for (const migration of migrationsToApply) {
+    console.log(`### MIGRATION ${migration.name} (UP) ###`);
+    await client.query(migration.sql);
+    await client.query(
+      `INSERT INTO "${migrationsTable}" (name) VALUES ($1)`,
+      [migration.name]
+    );
+  }
+}
+async function runMigrations({
+  namespace,
+  url,
+  dir,
+  direction = "up",
+  count,
+  dryRun = false
+}) {
+  const migrationsTable = `hexai__migrations_${namespace}` ;
+  const client = new pg.Client(url);
+  try {
+    await client.connect();
+    await ensureTableCompatibility(client, migrationsTable);
+    const isSqlFormat = await isSqlMigrationFormat(dir);
+    if (isSqlFormat) {
+      await runSqlMigrations(client, dir, migrationsTable, dryRun);
+    } else {
+      await client.end();
+      await runner({
+        databaseUrl: url.toString(),
+        dir,
+        direction,
+        count,
+        migrationsTable,
+        dryRun,
+        singleTransaction: true,
+        log: (msg) => {
+          if (!msg.startsWith("Can't determine timestamp for")) {
+            console.log(msg);
+          }
         }
-        this.closed = true;
-        await this.client.query(`ROLLBACK TO SAVEPOINT ${this.name}`);
-        this.onClose();
+      });
+      return;
     }
-    isAborted() {
-        return this.abortError !== undefined && !this.closed;
+  } finally {
+    try {
+      await client.end();
+    } catch {
     }
+  }
 }
+
+// src/run-hexai-migrations.ts
+var __dirname$1 = path2__default.dirname(fileURLToPath(import.meta.url));
+var MIGRATIONS_DIR = path2__default.join(__dirname$1, "../migrations");
+async function runHexaiMigrations(dbUrl) {
+  await runMigrations({
+    dir: MIGRATIONS_DIR,
+    url: dbUrl,
+    namespace: "hexai"
+  });
+}
+
+// src/test.ts
+function createTestContext(dbUrl) {
+  const config = typeof dbUrl === "string" ? PostgresConfig.fromUrl(dbUrl) : dbUrl;
+  const dbName = config.database;
+  const databaseManager = new DatabaseManager(
+    config.withDatabase("postgres")
+  );
+  const tableManager = new TableManager(config);
+  async function setup() {
+    try {
+      await databaseManager.dropDatabase(dbName);
+    } catch (e) {
+      if (isDatabaseError(e) && e.code === "3D000") ; else {
+        throw e;
+      }
+    }
+    await databaseManager.createDatabase(dbName);
+    await runHexaiMigrations(config);
+  }
+  async function teardown() {
+    await tableManager.close();
+    await databaseManager.dropDatabase(dbName);
+    await databaseManager.close();
+  }
+  return {
+    client: tableManager.getClient(),
+    newClient: () => new Client(dbUrl),
+    tableManager,
+    setup,
+    teardown
+  };
+}
+var PostgresUnitOfWorkForTesting = class {
+  constructor(client) {
+    this.client = client;
+  }
+  executorStorage = new AsyncLocalStorage();
+  getClient() {
+    const executor = this.getCurrentExecutor();
+    if (!executor) {
+      throw new Error("Unit of work not started");
+    }
+    return this.client;
+  }
+  async withClient(fn) {
+    return fn(this.client);
+  }
+  async wrap(fn, options = {}) {
+    const resolvedOptions = this.resolveOptions(options);
+    const executor = this.resolveExecutor(resolvedOptions);
+    return this.executeInContext(
+      executor,
+      (exec) => exec.execute(fn, resolvedOptions)
+    );
+  }
+  getCurrentExecutor() {
+    return this.executorStorage.getStore() ?? null;
+  }
+  resolveOptions(options) {
+    return {
+      propagation: Propagation.EXISTING,
+      ...options
+    };
+  }
+  resolveExecutor(options) {
+    if (options.propagation === Propagation.NEW) {
+      console.warn(
+        "[PostgresUnitOfWorkForTesting] Propagation.NEW is not fully supported in testing mode. Using savepoint instead."
+      );
+      return this.createExecutor();
+    }
+    return this.getCurrentExecutor() ?? this.createExecutor();
+  }
+  createExecutor() {
+    return new TestTransactionExecutor(this.client);
+  }
+  executeInContext(executor, callback) {
+    return this.executorStorage.run(executor, () => callback(executor));
+  }
+};
+var TestTransactionExecutor = class {
+  constructor(client) {
+    this.client = client;
+    this.savepointName = `test_sp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  }
+  initialized = false;
+  closed = false;
+  abortError;
+  nestingDepth = 0;
+  savepointCounter = 0;
+  savepoints = [];
+  savepointName;
+  async execute(fn, options) {
+    await this.ensureStarted();
+    const executor = this.resolveExecutor(options.propagation);
+    return executor === this ? this.runWithLifecycle(fn) : executor.execute(fn, options);
+  }
+  getClient() {
+    return this.client;
+  }
+  async ensureStarted() {
+    if (this.initialized) {
+      return;
+    }
+    this.initialized = true;
+    await this.client.query(`SAVEPOINT ${this.savepointName}`);
+  }
+  async runWithLifecycle(fn) {
+    try {
+      return await this.executeWithNesting(fn);
+    } catch (e) {
+      this.markAsAborted(e);
+      throw e;
+    } finally {
+      await this.finalizeIfRoot();
+    }
+  }
+  async executeWithNesting(fn) {
+    this.nestingDepth++;
+    try {
+      return await fn(this.client);
+    } finally {
+      this.nestingDepth--;
+    }
+  }
+  markAsAborted(error) {
+    this.abortError = error;
+  }
+  async finalizeIfRoot() {
+    if (this.nestingDepth === 0) {
+      await (this.isAborted() ? this.rollback() : this.commit());
+    }
+  }
+  resolveExecutor(propagation) {
+    if (this.nestingDepth === 0) {
+      return this;
+    }
+    return propagation === Propagation.NESTED ? this.createSavepoint() : this.findActiveSavepoint() ?? this;
+  }
+  createSavepoint() {
+    this.savepointCounter++;
+    const savepoint = new TestSavepoint(
+      `${this.savepointName}_nested_${this.savepointCounter}`,
+      this.client,
+      () => this.removeSavepoint()
+    );
+    this.savepoints.push(savepoint);
+    return savepoint;
+  }
+  findActiveSavepoint() {
+    for (let i = this.savepoints.length - 1; i >= 0; i--) {
+      if (!this.savepoints[i].isClosed()) {
+        return this.savepoints[i];
+      }
+    }
+  }
+  removeSavepoint() {
+    this.savepoints.pop();
+  }
+  async commit() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    await this.client.query(`RELEASE SAVEPOINT ${this.savepointName}`);
+  }
+  async rollback() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    await this.client.query(
+      `ROLLBACK TO SAVEPOINT ${this.savepointName}`
+    );
+  }
+  isAborted() {
+    return this.abortError !== void 0 && !this.closed;
+  }
+};
+var TestSavepoint = class {
+  constructor(name, client, onClose) {
+    this.name = name;
+    this.client = client;
+    this.onClose = onClose;
+  }
+  initialized = false;
+  closed = false;
+  abortError;
+  nestingDepth = 0;
+  async execute(fn) {
+    await this.ensureStarted();
+    return this.runWithLifecycle(fn);
+  }
+  isClosed() {
+    return this.closed;
+  }
+  async ensureStarted() {
+    if (this.initialized) {
+      return;
+    }
+    this.initialized = true;
+    await this.client.query(`SAVEPOINT ${this.name}`);
+  }
+  async runWithLifecycle(fn) {
+    this.nestingDepth++;
+    try {
+      return await fn(this.client);
+    } catch (e) {
+      this.markAsAborted(e);
+      throw e;
+    } finally {
+      this.nestingDepth--;
+      await this.finalizeIfRoot();
+    }
+  }
+  markAsAborted(error) {
+    this.abortError = error;
+  }
+  async finalizeIfRoot() {
+    if (this.nestingDepth === 0) {
+      await (this.isAborted() ? this.rollback() : this.commit());
+    }
+  }
+  async commit() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    await this.client.query(`RELEASE SAVEPOINT ${this.name}`);
+    this.onClose();
+  }
+  async rollback() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    await this.client.query(`ROLLBACK TO SAVEPOINT ${this.name}`);
+    this.onClose();
+  }
+  isAborted() {
+    return this.abortError !== void 0 && !this.closed;
+  }
+};
+
+export { PostgresUnitOfWorkForTesting, createTestContext };
+//# sourceMappingURL=test.js.map
 //# sourceMappingURL=test.js.map