@hexaijs/postgres 0.3.0 → 0.5.0

package/dist/index.js

@@ -1,29 +1,829 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureConnection = exports.TableManager = exports.DatabaseManager = exports.ClientWrapper = void 0;
-__exportStar(require("./postgres-unit-of-work"), exports);
-__exportStar(require("./run-migrations"), exports);
-__exportStar(require("./run-hexai-migrations"), exports);
-var helpers_1 = require("./helpers");
-Object.defineProperty(exports, "ClientWrapper", { enumerable: true, get: function () { return helpers_1.ClientWrapper; } });
-Object.defineProperty(exports, "DatabaseManager", { enumerable: true, get: function () { return helpers_1.DatabaseManager; } });
-Object.defineProperty(exports, "TableManager", { enumerable: true, get: function () { return helpers_1.TableManager; } });
-Object.defineProperty(exports, "ensureConnection", { enumerable: true, get: function () { return helpers_1.ensureConnection; } });
-__exportStar(require("./postgres-event-store"), exports);
-// Config exports
-__exportStar(require("./config"), exports);
+import { AsyncLocalStorage } from 'async_hooks';
+import * as pg2 from 'pg';
+import { Propagation, Message } from '@hexaijs/core';
+import * as fs2 from 'fs/promises';
+import * as path2 from 'path';
+import path2__default from 'path';
+import runner from 'node-pg-migrate';
+import { fileURLToPath } from 'url';
+
+// src/postgres-unit-of-work.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 {
+      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/config/postgres-config-spec.ts
+var PostgresConfigSpec = class {
+  constructor(prefix, mode = "url") {
+    this.prefix = prefix;
+    this.mode = mode;
+  }
+  _type = "postgres";
+  resolve(errors) {
+    try {
+      return PostgresConfig.fromEnv(this.prefix, { mode: this.mode });
+    } catch (e) {
+      errors.push(e.message);
+      return void 0;
+    }
+  }
+};
+function postgresConfig(prefix, mode = "url") {
+  return new PostgresConfigSpec(prefix, mode);
+}
+
+// src/types.ts
+var IsolationLevel = /* @__PURE__ */ ((IsolationLevel2) => {
+  IsolationLevel2["READ_UNCOMMITTED"] = "read uncommitted";
+  IsolationLevel2["READ_COMMITTED"] = "read committed";
+  IsolationLevel2["REPEATABLE_READ"] = "repeatable read";
+  IsolationLevel2["SERIALIZABLE"] = "serializable";
+  return IsolationLevel2;
+})(IsolationLevel || {});
+var ClientWrapper = class {
+  client;
+  getClient() {
+    return this.client;
+  }
+  constructor(urlOrClient) {
+    if (urlOrClient instanceof PostgresConfig || typeof urlOrClient === "string") {
+      this.client = new pg2.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;
+    }
+  }
+}
+
+// src/postgres-unit-of-work.ts
+var DefaultPostgresUnitOfWork = class {
+  constructor(clientFactory, clientCleanUp) {
+    this.clientFactory = clientFactory;
+    this.clientCleanUp = clientCleanUp;
+  }
+  transactionStorage = new AsyncLocalStorage();
+  getClient() {
+    const current = this.getCurrentTransaction();
+    if (!current) {
+      throw new Error("Unit of work not started");
+    }
+    return current.getClient();
+  }
+  async wrap(fn, options = {}) {
+    const resolvedOptions = this.resolveOptions(options);
+    const transaction = this.resolveTransaction(resolvedOptions);
+    return this.executeInContext(
+      transaction,
+      (tx) => tx.execute(fn, resolvedOptions)
+    );
+  }
+  async withClient(fn) {
+    const currentTransaction = this.getCurrentTransaction();
+    if (currentTransaction) {
+      return fn(currentTransaction.getClient());
+    }
+    const client = await this.clientFactory();
+    try {
+      await ensureConnection(client);
+      return await fn(client);
+    } finally {
+      await this.clientCleanUp?.(client);
+    }
+  }
+  getCurrentTransaction() {
+    return this.transactionStorage.getStore() ?? null;
+  }
+  resolveOptions(options) {
+    return {
+      propagation: Propagation.EXISTING,
+      ...options
+    };
+  }
+  resolveTransaction(options) {
+    if (options.propagation === Propagation.NEW) {
+      return this.createTransaction();
+    }
+    return this.getCurrentTransaction() ?? this.createTransaction();
+  }
+  createTransaction() {
+    return new PostgresTransaction(this.clientFactory, this.clientCleanUp);
+  }
+  executeInContext(transaction, callback) {
+    return this.transactionStorage.run(
+      transaction,
+      () => callback(transaction)
+    );
+  }
+};
+var PostgresTransaction = class {
+  constructor(clientFactory, clientCleanUp) {
+    this.clientFactory = clientFactory;
+    this.clientCleanUp = clientCleanUp;
+  }
+  initialized = false;
+  closed = false;
+  abortError;
+  nestingDepth = 0;
+  options;
+  client;
+  savepoints = [];
+  async execute(fn, options) {
+    this.options = 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.initializeClient();
+    await this.beginTransaction();
+  }
+  async initializeClient() {
+    const client = await this.clientFactory();
+    if (!("query" in client)) {
+      throw new Error("Client factory must return a pg.ClientBase");
+    }
+    await ensureConnection(client);
+    this.client = client;
+  }
+  async beginTransaction() {
+    await this.client.query("BEGIN");
+    const isolationLevel = this.options.isolationLevel ?? "read committed" /* READ_COMMITTED */;
+    if (isolationLevel !== "read committed" /* READ_COMMITTED */) {
+      await this.client.query(
+        `SET TRANSACTION ISOLATION LEVEL ${isolationLevel}`
+      );
+    }
+  }
+  async runWithLifecycle(fn) {
+    try {
+      return await this.executeWithNesting(fn);
+    } catch (e) {
+      console.error(`Transaction aborting, error in transaction:`);
+      console.error(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() {
+    const savepoint = new Savepoint(
+      `sp_${this.savepoints.length + 1}`,
+      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("COMMIT");
+    await this.clientCleanUp?.(this.client);
+  }
+  async rollback() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    try {
+      await this.client.query("ROLLBACK");
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("Client was closed and is not queryable")) {
+        return;
+      }
+      throw e;
+    }
+    await this.clientCleanUp?.(this.client);
+  }
+  isAborted() {
+    return this.abortError !== void 0 && !this.closed;
+  }
+};
+var Savepoint = 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;
+  }
+};
+function createPostgresUnitOfWork(source) {
+  if (source instanceof pg2.Pool) {
+    return new DefaultPostgresUnitOfWork(
+      async () => source.connect(),
+      (client) => client.release()
+    );
+  }
+  const connectionString = source instanceof PostgresConfig ? source.toString() : source;
+  return new DefaultPostgresUnitOfWork(
+    () => new pg2.Client({ connectionString }),
+    (client) => client.end()
+  );
+}
+function extractNumericPrefix(filename) {
+  const match = filename.match(/^(\d+)/);
+  return match ? parseInt(match[1], 10) : 0;
+}
+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 {
+          await fs2.access(sqlPath);
+          return true;
+        } catch {
+        }
+      }
+    }
+    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 = namespace ? `hexai__migrations_${namespace}` : "hexai__migrations";
+  const client = new pg2.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);
+          }
+        }
+      });
+      return;
+    }
+  } finally {
+    try {
+      await client.end();
+    } catch {
+    }
+  }
+}
+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"
+  });
+}
+var DEFAULT_TABLE_NAME = "hexai__events";
+var COLUMNS_PER_EVENT = 3;
+var PostgresEventStore = class {
+  constructor(client, config = {}) {
+    this.client = client;
+    this.tableName = config.tableName ?? DEFAULT_TABLE_NAME;
+  }
+  tableName;
+  async store(event) {
+    const serialized = event.serialize();
+    const result = await this.client.query(
+      `INSERT INTO ${this.tableName} (message_type, headers, payload)
+             VALUES ($1, $2, $3)
+             RETURNING position`,
+      [
+        event.getMessageType(),
+        JSON.stringify(serialized.headers),
+        JSON.stringify(serialized.payload)
+      ]
+    );
+    return {
+      position: +result.rows[0].position,
+      event
+    };
+  }
+  async storeAll(events) {
+    if (events.length === 0) {
+      return [];
+    }
+    const values = [];
+    const placeholders = [];
+    events.forEach((event, index) => {
+      const serialized = event.serialize();
+      const offset = index * COLUMNS_PER_EVENT;
+      placeholders.push(
+        `($${offset + 1}, $${offset + 2}, $${offset + 3})`
+      );
+      values.push(
+        event.getMessageType(),
+        JSON.stringify(serialized.headers),
+        JSON.stringify(serialized.payload)
+      );
+    });
+    const result = await this.client.query(
+      `INSERT INTO ${this.tableName} (message_type, headers, payload)
+             VALUES ${placeholders.join(", ")}
+             RETURNING position`,
+      values
+    );
+    return result.rows.map((row, index) => ({
+      position: +row.position,
+      event: events[index]
+    }));
+  }
+  async fetch(afterPosition, limit) {
+    const lastPosition = await this.getLastPosition();
+    let query = `
+            SELECT position, message_type, headers, payload
+            FROM ${this.tableName}
+            WHERE position > $1
+            ORDER BY position ASC
+        `;
+    const params = [afterPosition];
+    if (limit !== void 0) {
+      query += ` LIMIT $2`;
+      params.push(limit);
+    }
+    const result = await this.client.query(query, params);
+    const events = result.rows.map(
+      (row) => this.deserializeRow(row)
+    );
+    return {
+      events,
+      lastPosition
+    };
+  }
+  async getLastPosition() {
+    const result = await this.client.query(
+      `SELECT MAX(position) as max FROM ${this.tableName}`
+    );
+    return +(result.rows[0].max ?? 0);
+  }
+  deserializeRow(row) {
+    const headers = row.headers;
+    const payload = row.payload;
+    const event = Message.from(payload, headers);
+    return {
+      position: +row.position,
+      event
+    };
+  }
+};
+
+export { ClientWrapper, DatabaseManager, DefaultPostgresUnitOfWork, IsolationLevel, PostgresConfig, PostgresConfigSpec, PostgresEventStore, TableManager, createPostgresUnitOfWork, ensureConnection, postgresConfig, runHexaiMigrations, runMigrations };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map