@event-driven-io/emmett-testcontainers 0.43.0-beta.3 → 0.43.0-beta.30

package/dist/index.js

@@ -1,362 +1,327 @@
-// src/eventStore/index.ts
-import { EventStoreDBClient as EventStoreDBClient2 } from "@eventstore/db-client";
+import { EventStoreDBClient } from "@eventstore/db-client";
+import { InProcessLock } from "@event-driven-io/emmett";
+import { AbstractStartedContainer, GenericContainer, Wait } from "testcontainers";
+import { MongoDBContainer } from "@testcontainers/mongodb";
+import { PostgreSqlContainer } from "@testcontainers/postgresql";
 
-// ../emmett/dist/chunk-AZDDB5SF.js
-var isNumber = (val) => typeof val === "number" && val === val;
-var isString = (val) => typeof val === "string";
-var EmmettError = class _EmmettError extends Error {
-  static Codes = {
-    ValidationError: 400,
-    IllegalStateError: 403,
-    NotFoundError: 404,
-    ConcurrencyError: 412,
-    InternalServerError: 500
-  };
-  errorCode;
-  constructor(options) {
-    const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : _EmmettError.Codes.InternalServerError;
-    const message = options && typeof options === "object" && "message" in options ? options.message : isString(options) ? options : `Error with status code '${errorCode}' ocurred during Emmett processing`;
-    super(message);
-    this.errorCode = errorCode;
-    Object.setPrototypeOf(this, _EmmettError.prototype);
-  }
-  static mapFrom(error) {
-    if (_EmmettError.isInstanceOf(error)) {
-      return error;
-    }
-    return new _EmmettError({
-      errorCode: "errorCode" in error && error.errorCode !== void 0 && error.errorCode !== null ? error.errorCode : _EmmettError.Codes.InternalServerError,
-      message: error.message ?? "An unknown error occurred"
-    });
-  }
-  static isInstanceOf(error, errorCode) {
-    return typeof error === "object" && error !== null && "errorCode" in error && isNumber(error.errorCode) && (errorCode === void 0 || error.errorCode === errorCode);
-  }
+//#region ../almanac/dist/logger-DnrSjS8d.js
+const LogLevel = {
+	default: "info",
+	silent: "silent",
+	trace: "trace",
+	debug: "debug",
+	info: "info",
+	warn: "warn",
+	error: "error",
+	fatal: "fatal"
+};
+const shouldLog = (logLevel, definedLogLevel) => {
+	definedLogLevel ??= LogLevel.default;
+	switch (definedLogLevel) {
+		case "fatal": return logLevel === LogLevel.fatal;
+		case "error": return [LogLevel.fatal, LogLevel.error].includes(logLevel);
+		case "warn": return [
+			LogLevel.fatal,
+			LogLevel.error,
+			LogLevel.warn
+		].includes(logLevel);
+		case "info": return [
+			LogLevel.fatal,
+			LogLevel.error,
+			LogLevel.warn,
+			LogLevel.info
+		].includes(logLevel);
+		case "debug": return [
+			LogLevel.fatal,
+			LogLevel.error,
+			LogLevel.warn,
+			LogLevel.info,
+			LogLevel.debug
+		].includes(logLevel);
+		case "trace": return [
+			LogLevel.fatal,
+			LogLevel.error,
+			LogLevel.warn,
+			LogLevel.info,
+			LogLevel.debug,
+			LogLevel.trace
+		].includes(logLevel);
+		case "silent": return false;
+	}
+};
+const logEvent = (eventName, data, eventMetadata) => {
+	return {
+		name: eventName,
+		data,
+		metadata: {
+			...eventMetadata,
+			timestamp: eventMetadata.timestamp ?? Date.now()
+		}
+	};
+};
+const message = (level, body, data, eventMetadata) => {
+	if (data === void 0) return logEvent(body, { body }, {
+		level,
+		...eventMetadata
+	});
+	const eventData = { body };
+	if (data.error !== void 0) eventData.error = data.error;
+	if (data.attributes !== void 0) eventData.attributes = data.attributes;
+	return logEvent(body, eventData, {
+		level,
+		...eventMetadata
+	});
 };
+const forLevel = (level) => (msgOrObj, msgOrMetadata, eventMetadata) => {
+	if (typeof msgOrObj === "string") return logEvent(msgOrObj, { body: msgOrObj }, {
+		level,
+		...typeof msgOrMetadata === "string" ? eventMetadata : msgOrMetadata
+	});
+	const msg = typeof msgOrMetadata === "string" ? msgOrMetadata : void 0;
+	const overrides = eventMetadata ?? (typeof msgOrMetadata === "string" ? void 0 : msgOrMetadata);
+	if (msgOrObj instanceof Error) return logEvent(msg ?? "", {
+		error: msgOrObj,
+		body: msg
+	}, {
+		level,
+		...overrides
+	});
+	const { eventName, ...attributes } = msgOrObj;
+	return logEvent(typeof eventName === "string" ? eventName : msg ?? "", {
+		attributes,
+		body: msg
+	}, {
+		level,
+		...overrides
+	});
+};
+const LogEvent = Object.assign(logEvent, {
+	message,
+	fatal: forLevel("fatal"),
+	error: forLevel("error"),
+	warn: forLevel("warn"),
+	info: forLevel("info"),
+	debug: forLevel("debug"),
+	trace: forLevel("trace"),
+	silent: forLevel("silent")
+});
+const logger = (options) => {
+	const { event: sink, minLevel } = options;
+	return (event) => {
+		if (event.metadata.level === "silent" || !shouldLog(event.metadata.level, minLevel)) return;
+		sink(event);
+	};
+};
+const noopLogger = logger({ event: () => {} });
 
-// ../emmett/dist/index.js
-import { v4 as uuid4 } from "uuid";
-import { v7 as uuid } from "uuid";
-import retry from "async-retry";
-import { v7 as uuid2 } from "uuid";
-import { v4 as uuid3 } from "uuid";
-import { v7 as uuid5 } from "uuid";
-var emmettPrefix = "emt";
-var defaultTag = `${emmettPrefix}:default`;
-var unknownTag = `${emmettPrefix}:unknown`;
-var TaskProcessor = class {
-  constructor(options) {
-    this.options = options;
-  }
-  queue = [];
-  isProcessing = false;
-  activeTasks = 0;
-  activeGroups = /* @__PURE__ */ new Set();
-  enqueue(task, options) {
-    if (this.queue.length >= this.options.maxQueueSize) {
-      return Promise.reject(
-        new EmmettError(
-          "Too many pending connections. Please try again later."
-        )
-      );
-    }
-    return this.schedule(task, options);
-  }
-  waitForEndOfProcessing() {
-    return this.schedule(({ ack }) => Promise.resolve(ack()));
-  }
-  schedule(task, options) {
-    return promiseWithDeadline(
-      (resolve, reject) => {
-        const taskWithContext = () => {
-          return new Promise((resolveTask, failTask) => {
-            const taskPromise = task({
-              ack: resolveTask
-            });
-            taskPromise.then(resolve).catch((err) => {
-              failTask(err);
-              reject(err);
-            });
-          });
-        };
-        this.queue.push({ task: taskWithContext, options });
-        if (!this.isProcessing) {
-          this.ensureProcessing();
-        }
-      },
-      { deadline: this.options.maxTaskIdleTime }
-    );
-  }
-  ensureProcessing() {
-    if (this.isProcessing) return;
-    this.isProcessing = true;
-    this.processQueue();
-  }
-  processQueue() {
-    try {
-      while (this.activeTasks < this.options.maxActiveTasks && this.queue.length > 0) {
-        const item = this.takeFirstAvailableItem();
-        if (item === null) return;
-        const groupId = item.options?.taskGroupId;
-        if (groupId) {
-          this.activeGroups.add(groupId);
-        }
-        this.activeTasks++;
-        void this.executeItem(item);
-      }
-    } catch (error) {
-      console.error(error);
-      throw error;
-    } finally {
-      this.isProcessing = false;
-      if (this.hasItemsToProcess() && this.activeTasks < this.options.maxActiveTasks) {
-        this.ensureProcessing();
-      }
-    }
-  }
-  async executeItem({ task, options }) {
-    try {
-      await task();
-    } finally {
-      this.activeTasks--;
-      if (options && options.taskGroupId) {
-        this.activeGroups.delete(options.taskGroupId);
-      }
-      this.ensureProcessing();
-    }
-  }
-  takeFirstAvailableItem = () => {
-    const taskIndex = this.queue.findIndex(
-      (item2) => !item2.options?.taskGroupId || !this.activeGroups.has(item2.options.taskGroupId)
-    );
-    if (taskIndex === -1) {
-      return null;
-    }
-    const [item] = this.queue.splice(taskIndex, 1);
-    return item ?? null;
-  };
-  hasItemsToProcess = () => this.queue.findIndex(
-    (item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId)
-  ) !== -1;
+//#endregion
+//#region ../almanac/dist/spanLogEvent-ByQosuDu.js
+const bigIntReplacer = (_key, value) => {
+	return typeof value === "bigint" ? value.toString() : value;
+};
+const dateReplacer = (_key, value) => {
+	return value instanceof Date ? value.toISOString() : value;
+};
+const errorReplacer = (_key, value) => value instanceof Error ? {
+	type: value.constructor.name || "error",
+	message: value.message,
+	stack: value.stack
+} : value;
+const isFirstLetterNumeric = (str) => {
+	const c = str.charCodeAt(0);
+	return c >= 48 && c <= 57;
+};
+const isFirstLetterNumericOrMinus = (str) => {
+	const c = str.charCodeAt(0);
+	return c >= 48 && c <= 57 || c === 45;
+};
+const bigIntReviver = (_key, value, context) => {
+	if (typeof value === "number" && Number.isInteger(value) && !Number.isSafeInteger(value)) try {
+		return BigInt(context?.source ?? value.toString());
+	} catch {
+		return value;
+	}
+	if (typeof value === "string" && value.length > 15) {
+		if (isFirstLetterNumericOrMinus(value)) {
+			const num = Number(value);
+			if (Number.isFinite(num) && !Number.isSafeInteger(num)) try {
+				return BigInt(value);
+			} catch {}
+		}
+	}
+	return value;
 };
-var DEFAULT_PROMISE_DEADLINE = 2147483647;
-var promiseWithDeadline = (executor, options) => {
-  return new Promise((resolve, reject) => {
-    let taskStarted = false;
-    const maxWaitingTime = options.deadline || DEFAULT_PROMISE_DEADLINE;
-    let timeoutId = setTimeout(() => {
-      if (!taskStarted) {
-        reject(
-          new Error("Task was not started within the maximum waiting time")
-        );
-      }
-    }, maxWaitingTime);
-    executor((value) => {
-      taskStarted = true;
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      timeoutId = null;
-      resolve(value);
-    }, reject);
-  });
+const dateReviver = (_key, value) => {
+	if (typeof value === "string" && value.length === 24 && isFirstLetterNumeric(value) && value[10] === "T" && value[23] === "Z") {
+		const date = new Date(value);
+		if (!isNaN(date.getTime())) return date;
+	}
+	return value;
 };
-var InProcessLock = () => {
-  const taskProcessor = new TaskProcessor({
-    maxActiveTasks: Number.MAX_VALUE,
-    maxQueueSize: Number.MAX_VALUE
-  });
-  const locks = /* @__PURE__ */ new Map();
-  return {
-    async acquire({ lockId }) {
-      await new Promise((resolve, reject) => {
-        taskProcessor.enqueue(
-          ({ ack }) => {
-            locks.set(lockId, ack);
-            resolve();
-            return Promise.resolve();
-          },
-          { taskGroupId: lockId }
-        ).catch(reject);
-      });
-    },
-    async tryAcquire({ lockId }) {
-      if (locks.has(lockId)) {
-        return false;
-      }
-      await this.acquire({ lockId });
-      return true;
-    },
-    release({ lockId }) {
-      const ack = locks.get(lockId);
-      if (ack === void 0) {
-        return Promise.resolve(true);
-      }
-      locks.delete(lockId);
-      ack();
-      return Promise.resolve(true);
-    },
-    async withAcquire(handle, { lockId }) {
-      return taskProcessor.enqueue(
-        async ({ ack }) => {
-          locks.set(lockId, ack);
-          try {
-            return await handle();
-          } finally {
-            locks.delete(lockId);
-            ack();
-          }
-        },
-        { taskGroupId: lockId }
-      );
-    }
-  };
+const composeJSONReplacers = (...replacers) => {
+	const filteredReplacers = replacers.filter((r) => r !== void 0);
+	if (filteredReplacers.length === 0) return void 0;
+	return (key, value) => filteredReplacers.reduce((accValue, replacer) => replacer(key, accValue), value);
 };
-var textEncoder = new TextEncoder();
+const composeJSONRevivers = (...revivers) => {
+	const filteredRevivers = revivers.filter((r) => r !== void 0);
+	if (filteredRevivers.length === 0) return void 0;
+	return (key, value, context) => filteredRevivers.reduce((accValue, reviver) => reviver(key, accValue, context), value);
+};
+const JSONReplacer = (opts) => composeJSONReplacers(opts?.replacer, opts?.failOnBigIntSerialization !== true ? JSONReplacers.bigInt : void 0, opts?.useDefaultDateSerialization !== true ? JSONReplacers.date : void 0, opts?.skipErrorSerialization !== true ? JSONReplacers.error : void 0);
+const JSONReviver = (opts) => composeJSONRevivers(opts?.reviver, opts?.parseBigInts === true ? JSONRevivers.bigInt : void 0, opts?.parseDates === true ? JSONRevivers.date : void 0);
+const JSONReplacers = {
+	bigInt: bigIntReplacer,
+	date: dateReplacer,
+	error: errorReplacer
+};
+const JSONRevivers = {
+	bigInt: bigIntReviver,
+	date: dateReviver
+};
+const jsonSerializer = (options) => {
+	const defaultReplacer = JSONReplacer(options);
+	const defaultReviver = JSONReviver(options);
+	const defaultFormat = options?.format ?? "compact";
+	const defaultSafe = options?.safe ?? false;
+	return {
+		serialize: (object, serializerOptions) => {
+			const replacer = serializerOptions ? JSONReplacer(serializerOptions) : defaultReplacer;
+			const indent = (serializerOptions?.format ?? defaultFormat) === "pretty" ? 2 : void 0;
+			if (serializerOptions?.safe ?? defaultSafe) try {
+				return JSON.stringify(object, replacer, indent);
+			} catch (e) {
+				return `{"__serializationError":${JSON.stringify(String(e))}}`;
+			}
+			return JSON.stringify(object, replacer, indent);
+		},
+		deserialize: (payload, deserializerOptions) => JSON.parse(payload, deserializerOptions ? JSONReviver(deserializerOptions) : defaultReviver)
+	};
+};
+const JSONSerializer = Object.assign(jsonSerializer(), { from: (options) => options?.serialization?.serializer ?? (options?.serialization?.options ? jsonSerializer(options?.serialization?.options) : JSONSerializer) });
 
-// src/eventStore/eventStoreDBContainer.ts
-import { EventStoreDBClient } from "@eventstore/db-client";
-import {
-  AbstractStartedContainer,
-  GenericContainer,
-  Wait
-} from "testcontainers";
-var EVENTSTOREDB_PORT = 2113;
-var EVENTSTOREDB_IMAGE_NAME = "eventstore/eventstore";
-var EVENTSTOREDB_IMAGE_TAG = "24.10.0-bookworm-slim";
-var EVENTSTOREDB_ARM64_IMAGE_TAG = "24.10.0-alpha-arm64v8";
-var EVENTSTOREDB_DEFAULT_IMAGE = `${EVENTSTOREDB_IMAGE_NAME}:${process.arch !== "arm64" ? EVENTSTOREDB_IMAGE_TAG : EVENTSTOREDB_ARM64_IMAGE_TAG}`;
-var defaultEventStoreDBContainerOptions = {
-  disableProjections: false,
-  isSecure: false,
-  useFileStorage: false,
-  withReuse: false
+//#endregion
+//#region ../almanac/dist/console-Bn5yW7XZ.js
+const consoleMethodFor = (level) => {
+	switch (level) {
+		case "fatal":
+		case "error": return console.error;
+		case "warn": return console.warn;
+		case "debug": return console.debug;
+		case "trace": return console.trace;
+		default: return console.log;
+	}
+};
+const consoleLogger = logger({ event: (event) => {
+	const write = consoleMethodFor(event.metadata.level);
+	const extra = event.data.error ?? (event.data.attributes && Object.keys(event.data.attributes).length ? event.data.attributes : void 0);
+	if (event.data.body !== void 0 && extra !== void 0) write(event.data.body, extra);
+	else if (event.data.body !== void 0) write(event.data.body);
+	else if (extra !== void 0) write(extra);
+	else write("");
+} });
+
+//#endregion
+//#region src/eventStore/eventStoreDBContainer.ts
+const EVENTSTOREDB_PORT = 2113;
+const EVENTSTOREDB_IMAGE_NAME = "eventstore/eventstore";
+const EVENTSTOREDB_IMAGE_TAG = "24.10.0-bookworm-slim";
+const EVENTSTOREDB_ARM64_IMAGE_TAG = "24.10.0-alpha-arm64v8";
+const EVENTSTOREDB_DEFAULT_IMAGE = `${EVENTSTOREDB_IMAGE_NAME}:${process.arch !== "arm64" ? EVENTSTOREDB_IMAGE_TAG : EVENTSTOREDB_ARM64_IMAGE_TAG}`;
+const defaultEventStoreDBContainerOptions = {
+	disableProjections: false,
+	isSecure: false,
+	useFileStorage: false,
+	withReuse: false
 };
 var EventStoreDBContainer = class extends GenericContainer {
-  constructor(image = EVENTSTOREDB_DEFAULT_IMAGE, options = defaultEventStoreDBContainerOptions) {
-    super(image);
-    const environment = {
-      ...!options.disableProjections ? {
-        EVENTSTORE_RUN_PROJECTIONS: "ALL"
-      } : {},
-      ...!options.isSecure ? {
-        EVENTSTORE_INSECURE: "true"
-      } : {},
-      ...options.useFileStorage ? {
-        EVENTSTORE_MEM_DB: "false",
-        EVENTSTORE_DB: "/data/integration-tests"
-      } : {},
-      EVENTSTORE_CLUSTER_SIZE: "1",
-      EVENTSTORE_START_STANDARD_PROJECTIONS: "true",
-      EVENTSTORE_NODE_PORT: `${EVENTSTOREDB_PORT}`,
-      EVENTSTORE_ENABLE_ATOM_PUB_OVER_HTTP: "true"
-    };
-    this.withEnvironment(environment).withExposedPorts(EVENTSTOREDB_PORT);
-    if (options.withReuse) this.withReuse();
-    this.withWaitStrategy(
-      Wait.forAll([Wait.forHealthCheck(), Wait.forListeningPorts()])
-    );
-  }
-  async start() {
-    return new StartedEventStoreDBContainer(await super.start());
-  }
+	constructor(image = EVENTSTOREDB_DEFAULT_IMAGE, options = defaultEventStoreDBContainerOptions) {
+		super(image);
+		const environment = {
+			...!options.disableProjections ? { EVENTSTORE_RUN_PROJECTIONS: "ALL" } : {},
+			...!options.isSecure ? { EVENTSTORE_INSECURE: "true" } : {},
+			...options.useFileStorage ? {
+				EVENTSTORE_MEM_DB: "false",
+				EVENTSTORE_DB: "/data/integration-tests"
+			} : {},
+			EVENTSTORE_CLUSTER_SIZE: "1",
+			EVENTSTORE_START_STANDARD_PROJECTIONS: "true",
+			EVENTSTORE_NODE_PORT: `${EVENTSTOREDB_PORT}`,
+			EVENTSTORE_ENABLE_ATOM_PUB_OVER_HTTP: "true"
+		};
+		this.withEnvironment(environment).withExposedPorts(EVENTSTOREDB_PORT);
+		if (options.withReuse) this.withReuse();
+		this.withWaitStrategy(Wait.forAll([Wait.forHealthCheck(), Wait.forListeningPorts()]));
+	}
+	async start() {
+		return new StartedEventStoreDBContainer(await super.start());
+	}
 };
 var StartedEventStoreDBContainer = class extends AbstractStartedContainer {
-  constructor(container2) {
-    super(container2);
-  }
-  getConnectionString() {
-    return `esdb://${this.getHost()}:${this.getMappedPort(2113)}?tls=false`;
-  }
-  getClient() {
-    return EventStoreDBClient.connectionString(this.getConnectionString());
-  }
+	constructor(container) {
+		super(container);
+	}
+	getConnectionString() {
+		return `esdb://${this.getHost()}:${this.getMappedPort(2113)}?tls=false`;
+	}
+	getClient() {
+		return EventStoreDBClient.connectionString(this.getConnectionString());
+	}
 };
-var container = null;
-var startedContainer = null;
-var startedCount = 0;
-var lock = InProcessLock();
-var getSharedEventStoreDBTestContainer = () => lock.withAcquire(
-  async () => {
-    if (startedContainer) return startedContainer;
-    if (!container)
-      container = new EventStoreDBContainer(EVENTSTOREDB_DEFAULT_IMAGE);
-    startedContainer = await container.start();
-    startedCount++;
-    container.withLogConsumer(
-      (stream) => stream.on("data", (line) => console.log(line)).on("err", (line) => console.error(line)).on("end", () => console.log("Stream closed"))
-    );
-    return startedContainer;
-  },
-  { lockId: "SharedEventStoreDBTestContainer" }
-);
-var getSharedTestEventStoreDBClient = async () => {
-  return (await getSharedEventStoreDBTestContainer()).getClient();
+let container = null;
+let startedContainer = null;
+let startedCount = 0;
+const lock = InProcessLock();
+const getSharedEventStoreDBTestContainer = () => lock.withAcquire(async () => {
+	if (startedContainer) return startedContainer;
+	if (!container) container = new EventStoreDBContainer(EVENTSTOREDB_DEFAULT_IMAGE);
+	startedContainer = await container.start();
+	startedCount++;
+	container.withLogConsumer((stream) => stream.on("data", (line) => consoleLogger(LogEvent.info(String(line)))).on("err", (line) => consoleLogger(LogEvent.error(String(line)))).on("end", () => consoleLogger(LogEvent.info("Stream closed"))));
+	return startedContainer;
+}, { lockId: "SharedEventStoreDBTestContainer" });
+const getSharedTestEventStoreDBClient = async () => {
+	return (await getSharedEventStoreDBTestContainer()).getClient();
 };
-var releaseSharedEventStoreDBTestContainer = () => lock.withAcquire(
-  async () => {
-    const containerToStop = startedContainer;
-    if (containerToStop && --startedCount === 0) {
-      try {
-        startedContainer = null;
-        container = null;
-        await containerToStop.stop();
-      } catch {
-      }
-    }
-  },
-  { lockId: "SharedEventStoreDBTestContainer" }
-);
+const releaseSharedEventStoreDBTestContainer = () => lock.withAcquire(async () => {
+	const containerToStop = startedContainer;
+	if (containerToStop && --startedCount === 0) try {
+		startedContainer = null;
+		container = null;
+		await containerToStop.stop();
+	} catch {}
+}, { lockId: "SharedEventStoreDBTestContainer" });
 
-// src/eventStore/index.ts
-var esdbContainer;
-var getEventStoreDBTestClient = async (useTestContainers = false) => {
-  let connectionString;
-  if (useTestContainers) {
-    if (!esdbContainer)
-      esdbContainer = await new EventStoreDBContainer().start();
-    connectionString = esdbContainer.getConnectionString();
-  } else {
-    connectionString = "esdb://localhost:2113?tls=false";
-  }
-  return EventStoreDBClient2.connectionString(connectionString);
+//#endregion
+//#region src/eventStore/index.ts
+let esdbContainer;
+const getEventStoreDBTestClient = async (useTestContainers = false) => {
+	let connectionString;
+	if (useTestContainers) {
+		if (!esdbContainer) esdbContainer = await new EventStoreDBContainer().start();
+		connectionString = esdbContainer.getConnectionString();
+	} else connectionString = "esdb://localhost:2113?tls=false";
+	return EventStoreDBClient.connectionString(connectionString);
 };
 
-// src/mongodb/mongoDBContainer.ts
-import { MongoDBContainer } from "@testcontainers/mongodb";
-var getMongoDBContainer = (options = { version: "6.0.1" }) => {
-  return new MongoDBContainer(`mongo:${options.version}`);
+//#endregion
+//#region src/mongodb/mongoDBContainer.ts
+const getMongoDBContainer = (options = { version: "6.0.1" }) => {
+	return new MongoDBContainer(`mongo:${options.version}`);
 };
-var getMongoDBStartedContainer = async (options = { version: "6.0.1" }) => {
-  const container2 = getMongoDBContainer(options);
-  return container2.start();
+const getMongoDBStartedContainer = async (options = { version: "6.0.1" }) => {
+	return getMongoDBContainer(options).start();
 };
 
-// src/postgresql/postgreSQLContainer.ts
-import { PostgreSqlContainer } from "@testcontainers/postgresql";
-var getPostgreSQLContainer = (options = { version: "18.1" }) => {
-  return new PostgreSqlContainer(`postgres:${options.version}`);
+//#endregion
+//#region src/postgresql/postgreSQLContainer.ts
+const getPostgreSQLContainer = (options = { version: "18.1" }) => {
+	return new PostgreSqlContainer(`postgres:${options.version}`);
 };
-var getPostgreSQLStartedContainer = async (options = { version: "18.1" }) => {
-  const container2 = getPostgreSQLContainer(options);
-  return container2.start();
-};
-export {
-  EVENTSTOREDB_ARM64_IMAGE_TAG,
-  EVENTSTOREDB_DEFAULT_IMAGE,
-  EVENTSTOREDB_IMAGE_NAME,
-  EVENTSTOREDB_IMAGE_TAG,
-  EVENTSTOREDB_PORT,
-  EventStoreDBContainer,
-  StartedEventStoreDBContainer,
-  defaultEventStoreDBContainerOptions,
-  getEventStoreDBTestClient,
-  getMongoDBContainer,
-  getMongoDBStartedContainer,
-  getPostgreSQLContainer,
-  getPostgreSQLStartedContainer,
-  getSharedEventStoreDBTestContainer,
-  getSharedTestEventStoreDBClient,
-  releaseSharedEventStoreDBTestContainer
+const getPostgreSQLStartedContainer = async (options = { version: "18.1" }) => {
+	return getPostgreSQLContainer(options).start();
 };
+
+//#endregion
+export { EVENTSTOREDB_ARM64_IMAGE_TAG, EVENTSTOREDB_DEFAULT_IMAGE, EVENTSTOREDB_IMAGE_NAME, EVENTSTOREDB_IMAGE_TAG, EVENTSTOREDB_PORT, EventStoreDBContainer, StartedEventStoreDBContainer, defaultEventStoreDBContainerOptions, getEventStoreDBTestClient, getMongoDBContainer, getMongoDBStartedContainer, getPostgreSQLContainer, getPostgreSQLStartedContainer, getSharedEventStoreDBTestContainer, getSharedTestEventStoreDBClient, releaseSharedEventStoreDBTestContainer };
 //# sourceMappingURL=index.js.map