@event-driven-io/emmett-testcontainers 0.43.0-beta.2 → 0.43.0-beta.20

package/dist/index.js

@@ -1,362 +1,109 @@
-// src/eventStore/index.ts
-import { EventStoreDBClient as EventStoreDBClient2 } from "@eventstore/db-client";
-
-// ../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);
-  }
-};
-
-// ../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;
-};
-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);
-  });
-};
-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 }
-      );
-    }
-  };
-};
-var textEncoder = new TextEncoder();
-
-// 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
+import { InProcessLock } from "@event-driven-io/emmett";
+import { AbstractStartedContainer, GenericContainer, Wait } from "testcontainers";
+import { MongoDBContainer } from "@testcontainers/mongodb";
+import { PostgreSqlContainer } from "@testcontainers/postgresql";
+
+//#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) => console.log(line)).on("err", (line) => console.error(line)).on("end", () => console.log("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}`);
-};
-var getPostgreSQLStartedContainer = async (options = { version: "18.1" }) => {
-  const container2 = getPostgreSQLContainer(options);
-  return container2.start();
+//#endregion
+//#region src/postgresql/postgreSQLContainer.ts
+const getPostgreSQLContainer = (options = { version: "18.1" }) => {
+	return new PostgreSqlContainer(`postgres:${options.version}`);
 };
-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