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

package/dist/index.js

@@ -1,464 +1,251 @@
-// src/index.ts
 import "express-async-errors";
-
-// src/application.ts
 import express, { Router } from "express";
-import "express-async-errors";
 import http from "http";
-
-// ../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 ParseError = class extends Error {
-  constructor(text) {
-    super(`Cannot parse! ${text}`);
-  }
-};
-var JSONParser = {
-  stringify: (value, options) => {
-    return JSON.stringify(
-      options?.map ? options.map(value) : value,
-      //TODO: Consider adding support to DateTime and adding specific format to mark that's a bigint
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      (_, v) => typeof v === "bigint" ? v.toString() : v
-    );
-  },
-  parse: (text, options) => {
-    const parsed = JSON.parse(text, options?.reviver);
-    if (options?.typeCheck && !options?.typeCheck(parsed))
-      throw new ParseError(text);
-    return options?.map ? options.map(parsed) : parsed;
-  }
-};
-var textEncoder = new TextEncoder();
-var AssertionError = class extends Error {
-  constructor(message2) {
-    super(message2);
-  }
-};
-var isSubset = (superObj, subObj) => {
-  const sup = superObj;
-  const sub = subObj;
-  assertOk(sup);
-  assertOk(sub);
-  return Object.keys(sub).every((ele) => {
-    if (sub[ele] !== null && typeof sub[ele] == "object") {
-      return isSubset(sup[ele], sub[ele]);
-    }
-    return sub[ele] === sup[ele];
-  });
-};
-var assertFails = (message2) => {
-  throw new AssertionError(message2 ?? "That should not ever happened, right?");
-};
-var assertMatches = (actual, expected, message2) => {
-  if (!isSubset(actual, expected))
-    throw new AssertionError(
-      message2 ?? `subObj:
-${JSONParser.stringify(expected)}
-is not subset of
-${JSONParser.stringify(actual)}`
-    );
-};
-function assertOk(obj, message2) {
-  if (!obj) throw new AssertionError(message2 ?? `Condition is not truthy`);
-}
-function assertEqual(expected, actual, message2) {
-  if (expected !== actual)
-    throw new AssertionError(
-      `${message2 ?? "Objects are not equal"}:
-Expected: ${JSONParser.stringify(expected)}
-Actual: ${JSONParser.stringify(actual)}`
-    );
-}
-var WrapEventStore = (eventStore) => {
-  const appendedEvents = /* @__PURE__ */ new Map();
-  const wrapped = {
-    ...eventStore,
-    aggregateStream(streamName, options) {
-      return eventStore.aggregateStream(streamName, options);
-    },
-    async readStream(streamName, options) {
-      return await eventStore.readStream(
-        streamName,
-        options
-      );
-    },
-    appendToStream: async (streamName, events, options) => {
-      const result = await eventStore.appendToStream(
-        streamName,
-        events,
-        options
-      );
-      const currentStream = appendedEvents.get(streamName) ?? [streamName, []];
-      appendedEvents.set(streamName, [
-        streamName,
-        [...currentStream[1], ...events]
-      ]);
-      return result;
-    },
-    appendedEvents,
-    setup: async (streamName, events) => {
-      return eventStore.appendToStream(streamName, events);
-    }
-    // streamEvents: (): ReadableStream<
-    //   // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-    //   ReadEvent<Event, ReadEventMetadataType> | GlobalSubscriptionEvent
-    // > => {
-    //   return eventStore.streamEvents();
-    // },
-  };
-  return wrapped;
-};
-
-// src/middlewares/problemDetailsMiddleware.ts
+import { EmmettError, WrapEventStore, assertEqual, assertFails, assertMatches, getInMemoryEventStore, isNumber } from "@event-driven-io/emmett";
 import { ProblemDocument } from "http-problem-details";
-var problemDetailsMiddleware = (mapError) => (error, request, response, _next) => {
-  let problemDetails;
-  if (mapError) problemDetails = mapError(error, request);
-  problemDetails = problemDetails ?? defaultErrorToProblemDetailsMapping(error);
-  sendProblem(response, problemDetails.status, { problem: problemDetails });
-};
-var defaultErrorToProblemDetailsMapping = (error) => {
-  let statusCode = 500;
-  if ("errorCode" in error && isNumber(error.errorCode) && error.errorCode >= 100 && error.errorCode < 600) {
-    statusCode = error.errorCode;
-  }
-  return new ProblemDocument({
-    detail: error.message,
-    status: statusCode
-  });
-};
+import supertest from "supertest";
+import assert from "assert";
 
-// src/application.ts
-var getApplication = (options) => {
-  const app = express();
-  const {
-    apis,
-    mapError,
-    enableDefaultExpressEtag,
-    disableJsonMiddleware,
-    disableUrlEncodingMiddleware,
-    disableProblemDetailsMiddleware
-  } = options;
-  const router = Router();
-  app.set("etag", enableDefaultExpressEtag ?? false);
-  if (!disableJsonMiddleware) app.use(express.json());
-  if (!disableUrlEncodingMiddleware)
-    app.use(
-      express.urlencoded({
-        extended: true
-      })
-    );
-  for (const api of apis) {
-    api(router);
-  }
-  app.use(router);
-  if (!disableProblemDetailsMiddleware)
-    app.use(problemDetailsMiddleware(mapError));
-  return app;
-};
-var startAPI = (app, options = { port: 3e3 }) => {
-  const { port } = options;
-  const server = http.createServer(app);
-  server.on("listening", () => {
-    console.info("server up listening");
-  });
-  return server.listen(port);
+//#region src/middlewares/problemDetailsMiddleware.ts
+const problemDetailsMiddleware = (mapError) => (error, request, response, _next) => {
+	let problemDetails;
+	if (mapError) problemDetails = mapError(error, request);
+	problemDetails = problemDetails ?? defaultErrorToProblemDetailsMapping(error);
+	sendProblem(response, problemDetails.status, { problem: problemDetails });
+};
+const defaultErrorToProblemDetailsMapping = (error) => {
+	let statusCode = 500;
+	if ("errorCode" in error && isNumber(error.errorCode) && error.errorCode >= 100 && error.errorCode < 600) statusCode = error.errorCode;
+	return new ProblemDocument({
+		detail: error.message,
+		status: statusCode
+	});
 };
 
-// src/etag.ts
-var HeaderNames = {
-  IF_MATCH: "if-match",
-  IF_NOT_MATCH: "if-not-match",
-  ETag: "etag"
-};
-var WeakETagRegex = /W\/"(-?\d+.*)"/;
-var ETagErrors = /* @__PURE__ */ ((ETagErrors2) => {
-  ETagErrors2["WRONG_WEAK_ETAG_FORMAT"] = "WRONG_WEAK_ETAG_FORMAT";
-  ETagErrors2["MISSING_IF_MATCH_HEADER"] = "MISSING_IF_MATCH_HEADER";
-  ETagErrors2["MISSING_IF_NOT_MATCH_HEADER"] = "MISSING_IF_NOT_MATCH_HEADER";
-  return ETagErrors2;
-})(ETagErrors || {});
-var isWeakETag = (etag) => {
-  return WeakETagRegex.test(etag);
+//#endregion
+//#region src/application.ts
+const getApplication = (options) => {
+	const app = express();
+	const { apis, mapError, enableDefaultExpressEtag, disableJsonMiddleware, disableUrlEncodingMiddleware, disableProblemDetailsMiddleware } = options;
+	const router = Router();
+	app.set("etag", enableDefaultExpressEtag ?? false);
+	if (!disableJsonMiddleware) app.use(express.json());
+	if (!disableUrlEncodingMiddleware) app.use(express.urlencoded({ extended: true }));
+	for (const api of apis) api(router);
+	app.use(router);
+	if (!disableProblemDetailsMiddleware) app.use(problemDetailsMiddleware(mapError));
+	return app;
+};
+const startAPI = (app, options = { port: 3e3 }) => {
+	const { port } = options;
+	const server = http.createServer(app);
+	server.on("listening", () => {
+		console.info("server up listening");
+	});
+	return server.listen(port);
 };
-var getWeakETagValue = (etag) => {
-  const result = WeakETagRegex.exec(etag);
-  if (result === null || result.length === 0) {
-    throw new EmmettError({
-      errorCode: EmmettError.Codes.ConcurrencyError,
-      message: "WRONG_WEAK_ETAG_FORMAT" /* WRONG_WEAK_ETAG_FORMAT */
-    });
-  }
-  return result[1];
-};
-var toWeakETag = (value) => {
-  return `W/"${value}"`;
-};
-var getETagFromIfMatch = (request) => {
-  const etag = request.headers[HeaderNames.IF_MATCH];
-  if (etag === void 0) {
-    throw new EmmettError({
-      errorCode: EmmettError.Codes.ConcurrencyError,
-      message: "MISSING_IF_MATCH_HEADER" /* MISSING_IF_MATCH_HEADER */
-    });
-  }
-  return etag;
-};
-var getETagFromIfNotMatch = (request) => {
-  const etag = request.headers[HeaderNames.IF_NOT_MATCH];
-  if (etag === void 0) {
-    throw new EmmettError({
-      errorCode: EmmettError.Codes.ConcurrencyError,
-      message: "MISSING_IF_NOT_MATCH_HEADER" /* MISSING_IF_NOT_MATCH_HEADER */
-    });
-  }
-  return Array.isArray(etag) ? etag[0] : etag;
-};
-var setETag = (response, etag) => {
-  response.setHeader(HeaderNames.ETag, etag);
-};
-var getETagValueFromIfMatch = (request) => {
-  const eTagValue = getETagFromIfMatch(request);
-  return isWeakETag(eTagValue) ? getWeakETagValue(eTagValue) : eTagValue;
+
+//#endregion
+//#region src/etag.ts
+const HeaderNames = {
+	IF_MATCH: "if-match",
+	IF_NOT_MATCH: "if-not-match",
+	ETag: "etag"
+};
+const WeakETagRegex = /W\/"(-?\d+.*)"/;
+let ETagErrors = /* @__PURE__ */ function(ETagErrors) {
+	ETagErrors["WRONG_WEAK_ETAG_FORMAT"] = "WRONG_WEAK_ETAG_FORMAT";
+	ETagErrors["MISSING_IF_MATCH_HEADER"] = "MISSING_IF_MATCH_HEADER";
+	ETagErrors["MISSING_IF_NOT_MATCH_HEADER"] = "MISSING_IF_NOT_MATCH_HEADER";
+	return ETagErrors;
+}({});
+const isWeakETag = (etag) => {
+	return WeakETagRegex.test(etag);
+};
+const getWeakETagValue = (etag) => {
+	const result = WeakETagRegex.exec(etag);
+	if (result === null || result.length === 0) throw new EmmettError({
+		errorCode: EmmettError.Codes.ConcurrencyError,
+		message: "WRONG_WEAK_ETAG_FORMAT"
+	});
+	return result[1];
+};
+const toWeakETag = (value) => {
+	return `W/"${value}"`;
+};
+const getETagFromIfMatch = (request) => {
+	const etag = request.headers[HeaderNames.IF_MATCH];
+	if (etag === void 0) throw new EmmettError({
+		errorCode: EmmettError.Codes.ConcurrencyError,
+		message: "MISSING_IF_MATCH_HEADER"
+	});
+	return etag;
+};
+const getETagFromIfNotMatch = (request) => {
+	const etag = request.headers[HeaderNames.IF_NOT_MATCH];
+	if (etag === void 0) throw new EmmettError({
+		errorCode: EmmettError.Codes.ConcurrencyError,
+		message: "MISSING_IF_NOT_MATCH_HEADER"
+	});
+	return Array.isArray(etag) ? etag[0] : etag;
+};
+const setETag = (response, etag) => {
+	response.setHeader(HeaderNames.ETag, etag);
+};
+const getETagValueFromIfMatch = (request) => {
+	const eTagValue = getETagFromIfMatch(request);
+	return isWeakETag(eTagValue) ? getWeakETagValue(eTagValue) : eTagValue;
 };
 
-// src/handler.ts
-var on = (handle) => async (request, response, _next) => {
-  const setResponse = await Promise.resolve(handle(request));
-  return setResponse(response);
+//#endregion
+//#region src/handler.ts
+const on = (handle) => async (request, response, _next) => {
+	return (await Promise.resolve(handle(request)))(response);
 };
-var OK = (options) => (response) => {
-  send(response, 200, options);
+const OK = (options) => (response) => {
+	send(response, 200, options);
 };
-var Created = (options) => (response) => {
-  sendCreated(response, options);
+const Created = (options) => (response) => {
+	sendCreated(response, options);
 };
-var Accepted = (options) => (response) => {
-  sendAccepted(response, options);
+const Accepted = (options) => (response) => {
+	sendAccepted(response, options);
 };
-var NoContent = (options) => HttpResponse(204, options);
-var HttpResponse = (statusCode, options) => (response) => {
-  send(response, statusCode, options);
+const NoContent = (options) => HttpResponse(204, options);
+const HttpResponse = (statusCode, options) => (response) => {
+	send(response, statusCode, options);
 };
-var BadRequest = (options) => HttpProblem(400, options);
-var Forbidden = (options) => HttpProblem(403, options);
-var NotFound = (options) => HttpProblem(404, options);
-var Conflict = (options) => HttpProblem(409, options);
-var PreconditionFailed = (options) => HttpProblem(412, options);
-var HttpProblem = (statusCode, options) => (response) => {
-  sendProblem(response, statusCode, options);
+const BadRequest = (options) => HttpProblem(400, options);
+const Forbidden = (options) => HttpProblem(403, options);
+const NotFound = (options) => HttpProblem(404, options);
+const Conflict = (options) => HttpProblem(409, options);
+const PreconditionFailed = (options) => HttpProblem(412, options);
+const HttpProblem = (statusCode, options) => (response) => {
+	sendProblem(response, statusCode, options);
 };
 
-// src/responses.ts
-import { ProblemDocument as ProblemDocument2 } from "http-problem-details";
-var DefaultHttpResponseOptions = {};
-var DefaultHttpProblemResponseOptions = {
-  problemDetails: "Error occured!"
-};
-var sendCreated = (response, { eTag, ...options }) => send(response, 201, {
-  location: "url" in options ? options.url : `${response.req.url}/${options.createdId}`,
-  body: "createdId" in options ? { id: options.createdId } : void 0,
-  eTag
+//#endregion
+//#region src/responses.ts
+const DefaultHttpResponseOptions = {};
+const DefaultHttpProblemResponseOptions = { problemDetails: "Error occured!" };
+const sendCreated = (response, { eTag, ...options }) => send(response, 201, {
+	location: "url" in options ? options.url : `${response.req.url}/${options.createdId}`,
+	body: "createdId" in options ? {
+		id: options.createdId,
+		...options.body ?? {}
+	} : options.body,
+	eTag
 });
-var sendAccepted = (response, options) => send(response, 202, options);
-var send = (response, statusCode, options) => {
-  const { location, body, eTag } = options ?? DefaultHttpResponseOptions;
-  if (eTag) setETag(response, eTag);
-  if (location) response.setHeader("Location", location);
-  if (body) {
-    response.statusCode = statusCode;
-    response.send(body);
-  } else {
-    response.sendStatus(statusCode);
-  }
-};
-var sendProblem = (response, statusCode, options) => {
-  options = options ?? DefaultHttpProblemResponseOptions;
-  const { location, eTag } = options;
-  const problemDetails = "problem" in options ? options.problem : new ProblemDocument2({
-    detail: options.problemDetails,
-    status: statusCode
-  });
-  if (eTag) setETag(response, eTag);
-  if (location) response.setHeader("Location", location);
-  response.setHeader("Content-Type", "application/problem+json");
-  response.statusCode = statusCode;
-  response.json(problemDetails);
+const sendAccepted = (response, options) => send(response, 202, options);
+const sendNoContent = (response, options) => send(response, 204, options);
+const send = (response, statusCode, options) => {
+	const { location, body, eTag } = options ?? DefaultHttpResponseOptions;
+	if (eTag) setETag(response, eTag);
+	if (location) response.setHeader("Location", location);
+	if (body) {
+		response.statusCode = statusCode;
+		response.send(body);
+	} else response.sendStatus(statusCode);
+};
+const sendProblem = (response, statusCode, options) => {
+	options = options ?? DefaultHttpProblemResponseOptions;
+	const { location, eTag } = options;
+	const problemDetails = "problem" in options ? options.problem : new ProblemDocument({
+		detail: options.problemDetails,
+		status: statusCode
+	});
+	if (eTag) setETag(response, eTag);
+	if (location) response.setHeader("Location", location);
+	response.setHeader("Content-Type", "application/problem+json");
+	response.statusCode = statusCode;
+	response.json(problemDetails);
 };
 
-// src/testing/apiE2ESpecification.ts
-import supertest from "supertest";
-import assert from "assert";
-var ApiE2ESpecification = {
-  for: (getEventStore, getApplication2) => {
-    {
-      return (...givenRequests) => {
-        const eventStore = getEventStore();
-        const application = getApplication2(eventStore);
-        return {
-          when: (setupRequest) => {
-            const handle = async () => {
-              for (const requestFn of givenRequests) {
-                await requestFn(supertest(application));
-              }
-              return setupRequest(supertest(application));
-            };
-            return {
-              then: async (verify) => {
-                const response = await handle();
-                verify.forEach((assertion) => {
-                  const succeeded = assertion(response);
-                  if (succeeded === false) assert.fail();
-                });
-              }
-            };
-          }
-        };
-      };
-    }
-  }
-};
+//#endregion
+//#region src/testing/apiE2ESpecification.ts
+function apiE2ESpecificationFor(optionsOrGetApplication, getApplication) {
+	const resolveApplication = () => {
+		if (typeof optionsOrGetApplication === "function" && getApplication) return getApplication(optionsOrGetApplication());
+		if (typeof optionsOrGetApplication !== "object") throw new EmmettError("Invalid arguments provided to apiE2ESpecificationFor. Expected either an options object or a getEventStore function and getApplication function.");
+		const eventStore = optionsOrGetApplication.getEventStore?.() ?? getInMemoryEventStore();
+		return optionsOrGetApplication.getApplication(eventStore);
+	};
+	return (...givenRequests) => {
+		const application = resolveApplication();
+		return { when: (setupRequest) => {
+			const handle = async () => {
+				for (const requestFn of givenRequests) await requestFn(supertest(application));
+				return setupRequest(supertest(application));
+			};
+			return { then: async (verify) => {
+				const response = await handle();
+				verify.forEach((assertion) => {
+					if (assertion(response) === false) assert.fail();
+				});
+			} };
+		} };
+	};
+}
+const ApiE2ESpecification = { for: apiE2ESpecificationFor };
 
-// src/testing/apiSpecification.ts
-import supertest2 from "supertest";
-var existingStream = (streamId, events) => {
-  return [streamId, events];
-};
-var expect = (streamId, events) => {
-  return [streamId, events];
-};
-var expectNewEvents = (streamId, events) => {
-  return [streamId, events];
-};
-var expectResponse = (statusCode, options) => (response) => {
-  const { body, headers } = options ?? {};
-  assertEqual(statusCode, response.statusCode, "Response code doesn't match");
-  if (body) assertMatches(response.body, body);
-  if (headers) assertMatches(response.headers, headers);
-};
-var expectError = (errorCode, problemDetails) => expectResponse(
-  errorCode,
-  problemDetails ? { body: problemDetails } : void 0
-);
-var ApiSpecification = {
-  for: (getEventStore, getApplication2) => {
-    {
-      return (...givenStreams) => {
-        const eventStore = WrapEventStore(getEventStore());
-        const application = getApplication2(eventStore);
-        return {
-          when: (setupRequest) => {
-            const handle = async () => {
-              for (const [streamName, events] of givenStreams) {
-                await eventStore.setup(streamName, events);
-              }
-              return setupRequest(supertest2(application));
-            };
-            return {
-              then: async (verify) => {
-                const response = await handle();
-                if (typeof verify === "function") {
-                  const succeeded = verify(response);
-                  if (succeeded === false) assertFails();
-                } else if (Array.isArray(verify)) {
-                  const [first, ...rest] = verify;
-                  if (typeof first === "function") {
-                    const succeeded = first(response);
-                    if (succeeded === false) assertFails();
-                  }
-                  const events = typeof first === "function" ? rest : verify;
-                  assertMatches(
-                    Array.from(eventStore.appendedEvents.values()),
-                    events
-                  );
-                }
-              }
-            };
-          }
-        };
-      };
-    }
-  }
-};
-export {
-  Accepted,
-  ApiE2ESpecification,
-  ApiSpecification,
-  BadRequest,
-  Conflict,
-  Created,
-  DefaultHttpProblemResponseOptions,
-  DefaultHttpResponseOptions,
-  ETagErrors,
-  Forbidden,
-  HeaderNames,
-  HttpProblem,
-  HttpResponse,
-  NoContent,
-  NotFound,
-  OK,
-  PreconditionFailed,
-  WeakETagRegex,
-  existingStream,
-  expect,
-  expectError,
-  expectNewEvents,
-  expectResponse,
-  getApplication,
-  getETagFromIfMatch,
-  getETagFromIfNotMatch,
-  getETagValueFromIfMatch,
-  getWeakETagValue,
-  isWeakETag,
-  on,
-  send,
-  sendAccepted,
-  sendCreated,
-  sendProblem,
-  setETag,
-  startAPI,
-  toWeakETag
-};
+//#endregion
+//#region src/testing/apiSpecification.ts
+const existingStream = (streamId, events) => {
+	return [streamId, events];
+};
+const expect = (streamId, events) => {
+	return [streamId, events];
+};
+const expectNewEvents = (streamId, events) => {
+	return [streamId, events];
+};
+const expectResponse = (statusCode, options) => (response) => {
+	const { body, headers } = options ?? {};
+	assertEqual(statusCode, response.statusCode, "Response code doesn't match");
+	if (body) assertMatches(response.body, body);
+	if (headers) assertMatches(response.headers, headers);
+};
+const expectError = (errorCode, problemDetails) => expectResponse(errorCode, problemDetails ? { body: problemDetails } : void 0);
+function apiSpecificationFor(optionsOrGetEventStore, getApplication) {
+	const resolveStoreAndApplication = () => {
+		if (typeof optionsOrGetEventStore === "function") {
+			const eventStore = WrapEventStore(optionsOrGetEventStore());
+			return {
+				eventStore,
+				application: getApplication(eventStore)
+			};
+		}
+		const eventStore = WrapEventStore(optionsOrGetEventStore.getEventStore());
+		return {
+			eventStore,
+			application: optionsOrGetEventStore.getApplication(eventStore)
+		};
+	};
+	return (...givenStreams) => {
+		const { eventStore, application } = resolveStoreAndApplication();
+		return { when: (setupRequest) => {
+			const handle = async () => {
+				for (const [streamName, events] of givenStreams) await eventStore.setup(streamName, events);
+				return setupRequest(supertest(application));
+			};
+			return { then: async (verify) => {
+				const response = await handle();
+				if (typeof verify === "function") {
+					if (verify(response) === false) assertFails();
+				} else if (Array.isArray(verify)) {
+					const [first, ...rest] = verify;
+					if (typeof first === "function") {
+						if (first(response) === false) assertFails();
+					}
+					const events = typeof first === "function" ? rest : verify;
+					assertMatches(Array.from(eventStore.appendedEvents.values()), events);
+				}
+			} };
+		} };
+	};
+}
+const ApiSpecification = { for: apiSpecificationFor };
+
+//#endregion
+export { Accepted, ApiE2ESpecification, ApiSpecification, BadRequest, Conflict, Created, DefaultHttpProblemResponseOptions, DefaultHttpResponseOptions, ETagErrors, Forbidden, HeaderNames, HttpProblem, HttpResponse, NoContent, NotFound, OK, PreconditionFailed, WeakETagRegex, existingStream, expect, expectError, expectNewEvents, expectResponse, getApplication, getETagFromIfMatch, getETagFromIfNotMatch, getETagValueFromIfMatch, getWeakETagValue, isWeakETag, on, send, sendAccepted, sendCreated, sendNoContent, sendProblem, setETag, startAPI, toWeakETag };
 //# sourceMappingURL=index.js.map