@event-driven-io/emmett-expressjs 0.20.2-alpha.4 → 0.20.2-alpha.5

package/dist/index.js

@@ -1,7 +1,627 @@
-import"express-async-errors";import v,{Router as me}from"express";import"express-async-errors";import ue from"http";var w=(e=>(e.NOT_A_NONEMPTY_STRING="NOT_A_NONEMPTY_STRING",e.NOT_A_POSITIVE_NUMBER="NOT_A_POSITIVE_NUMBER",e.NOT_AN_UNSIGNED_BIGINT="NOT_AN_UNSIGNED_BIGINT",e))(w||{}),y=e=>typeof e=="number"&&e===e;import{v4 as $e}from"uuid";import{TransformStream as Ge}from"web-streams-polyfill";import{v4 as Ye}from"uuid";import{v4 as q}from"uuid";import{TransformStream as V}from"web-streams-polyfill";import j from"async-retry";import{ReadableStream as Ze}from"web-streams-polyfill";import"web-streams-polyfill";import{TransformStream as W}from"web-streams-polyfill";import{TransformStream as U}from"web-streams-polyfill";import{TransformStream as J}from"web-streams-polyfill";import{TransformStream as L}from"web-streams-polyfill";import{TransformStream as z}from"web-streams-polyfill";import{TransformStream as ee}from"web-streams-polyfill";import{TransformStream as re}from"web-streams-polyfill";import{TransformStream as oe}from"web-streams-polyfill";import{TransformStream as ae}from"web-streams-polyfill";var F=(e,t={})=>new x(e,t),x=class extends V{constructor(e,t={}){super({cancel:r=>{console.log("Stream was canceled. Reason:",r),this.stopChecking()}}),this.onNoActiveReaderCallback=e,this.streamId=t?.streamId??q(),this.onNoActiveReaderCallback=e,this.startChecking(t?.intervalCheckInMs??20)}checkInterval=null;streamId;_isStopped=!1;get hasActiveSubscribers(){return!this._isStopped}startChecking(e){this.checkInterval=setInterval(()=>{this.checkNoActiveReader()},e)}stopChecking(){this.checkInterval&&(clearInterval(this.checkInterval),this.checkInterval=null,this._isStopped=!0,this.onNoActiveReaderCallback(this))}checkNoActiveReader(){!this.readable.locked&&!this._isStopped&&this.stopChecking()}};var B=async(e,t)=>t===void 0||t.retries===0?e():j(async r=>{try{return await e()}catch(s){throw t?.shouldRetryError&&!t.shouldRetryError(s)&&r(s),s}},t??{retries:0});var $=class extends Error{constructor(e){super(`Cannot parse! ${e}`)}},u={stringify:(e,t)=>JSON.stringify(t?.map?t.map(e):e,(r,s)=>typeof s=="bigint"?s.toString():s),parse:(e,t)=>{let r=JSON.parse(e,t?.reviver);if(t?.typeCheck&&!t?.typeCheck(r))throw new $(e);return t?.map?t.map(r):r}};var G=e=>new W({transform(t,r){e(t)&&r.enqueue(t)}}),Y=e=>new U({transform(t,r){r.enqueue(e(t))}}),K=(e,t)=>new A(e,t),A=class extends J{accumulator;reducer;constructor(e,t){super({transform:r=>{this.accumulator=this.reducer(this.accumulator,r)},flush:r=>{r.enqueue(this.accumulator),r.terminate()}}),this.accumulator=t,this.reducer=e}},X=(e,t,r={forever:!0,minTimeout:25})=>new L({start(s){B(()=>Z(e,t,s),r).catch(o=>{s.error(o)})}}),Z=async(e,t,r)=>{let s=e().getReader();try{let o;do{let n=await s.read();o=n.done,await t(n,r),o&&r.terminate()}while(!o)}finally{s.releaseLock()}},Q=e=>new O(e),O=class extends z{count=0;skip;constructor(e){super({transform:(t,r)=>{this.count++,this.count>this.skip&&r.enqueue(t)}}),this.skip=e}},te=e=>new ee({transform(t,r){r.enqueue(t),e(t)&&r.terminate()}}),se=e=>new re({async transform(t,r){if(!e(t)){r.enqueue(t);return}await Promise.resolve(),r.terminate()}}),ne=e=>new C(e),C=class extends oe{count=0;limit;constructor(e){super({transform:(t,r)=>{this.count<this.limit?(this.count++,r.enqueue(t)):r.terminate()}}),this.limit=e}},ie=e=>new ae({start(t){let r=setTimeout(()=>{t.terminate()},e),s=t.terminate.bind(t);t.terminate=()=>{clearTimeout(r),s()}},transform(t,r){r.enqueue(t)}}),pe={filter:G,take:ne,TakeTransformStream:C,skip:Q,SkipTransformStream:O,map:Y,notifyAboutNoActiveReadersStream:F,NotifyAboutNoActiveReadersStream:x,reduce:K,ReduceTransformStream:A,retry:X,stopAfter:te,stopOn:se,waitAtMost:ie},{retry:pt}=pe;var d=class extends Error{constructor(e){super(e)}},N=(e,t)=>{let r=e,s=t;return R(r),R(s),Object.keys(s).every(o=>typeof s[o]=="object"?N(r[o],s[o]):s[o]===r[o])},E=e=>{throw new d(e??"That should not ever happened, right?")};var f=(e,t,r)=>{if(!N(e,t))throw new d(r??`subObj:
-${u.stringify(t)}
+// 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-AEEEXE2R.js
+var isNumber = (val) => typeof val === "number" && val === val;
+
+// ../emmett/dist/index.js
+import { v4 as uuid3 } from "uuid";
+import { TransformStream } from "web-streams-polyfill";
+import { v4 as uuid2 } from "uuid";
+import { v4 as uuid } from "uuid";
+import { TransformStream as TransformStream2 } from "web-streams-polyfill";
+import retry from "async-retry";
+import { ReadableStream } from "web-streams-polyfill";
+import "web-streams-polyfill";
+import { TransformStream as TransformStream3 } from "web-streams-polyfill";
+import { TransformStream as TransformStream4 } from "web-streams-polyfill";
+import { TransformStream as TransformStream5 } from "web-streams-polyfill";
+import {
+  TransformStream as TransformStream6
+} from "web-streams-polyfill";
+import { TransformStream as TransformStream7 } from "web-streams-polyfill";
+import { TransformStream as TransformStream8 } from "web-streams-polyfill";
+import { TransformStream as TransformStream9 } from "web-streams-polyfill";
+import { TransformStream as TransformStream10 } from "web-streams-polyfill";
+import { TransformStream as TransformStream11 } from "web-streams-polyfill";
+var notifyAboutNoActiveReadersStream = (onNoActiveReaderCallback, options = {}) => new NotifyAboutNoActiveReadersStream(onNoActiveReaderCallback, options);
+var NotifyAboutNoActiveReadersStream = class extends TransformStream2 {
+  constructor(onNoActiveReaderCallback, options = {}) {
+    super({
+      cancel: (reason) => {
+        console.log("Stream was canceled. Reason:", reason);
+        this.stopChecking();
+      }
+    });
+    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
+    this.streamId = options?.streamId ?? uuid();
+    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
+    this.startChecking(options?.intervalCheckInMs ?? 20);
+  }
+  checkInterval = null;
+  streamId;
+  _isStopped = false;
+  get hasActiveSubscribers() {
+    return !this._isStopped;
+  }
+  startChecking(interval) {
+    this.checkInterval = setInterval(() => {
+      this.checkNoActiveReader();
+    }, interval);
+  }
+  stopChecking() {
+    if (!this.checkInterval) return;
+    clearInterval(this.checkInterval);
+    this.checkInterval = null;
+    this._isStopped = true;
+    this.onNoActiveReaderCallback(this);
+  }
+  checkNoActiveReader() {
+    if (!this.readable.locked && !this._isStopped) {
+      this.stopChecking();
+    }
+  }
+};
+var asyncRetry = async (fn, opts) => {
+  if (opts === void 0 || opts.retries === 0) return fn();
+  return retry(
+    async (bail) => {
+      try {
+        return await fn();
+      } catch (error2) {
+        if (opts?.shouldRetryError && !opts.shouldRetryError(error2)) {
+          bail(error2);
+        }
+        throw error2;
+      }
+    },
+    opts ?? { retries: 0 }
+  );
+};
+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 filter = (filter2) => new TransformStream3({
+  transform(chunk, controller) {
+    if (filter2(chunk)) {
+      controller.enqueue(chunk);
+    }
+  }
+});
+var map = (map2) => new TransformStream4({
+  transform(chunk, controller) {
+    controller.enqueue(map2(chunk));
+  }
+});
+var reduce = (reducer, initialValue) => new ReduceTransformStream(reducer, initialValue);
+var ReduceTransformStream = class extends TransformStream5 {
+  accumulator;
+  reducer;
+  constructor(reducer, initialValue) {
+    super({
+      transform: (chunk) => {
+        this.accumulator = this.reducer(this.accumulator, chunk);
+      },
+      flush: (controller) => {
+        controller.enqueue(this.accumulator);
+        controller.terminate();
+      }
+    });
+    this.accumulator = initialValue;
+    this.reducer = reducer;
+  }
+};
+var retryStream = (createSourceStream, handleChunk2, retryOptions = { forever: true, minTimeout: 25 }) => new TransformStream6({
+  start(controller) {
+    asyncRetry(
+      () => onRestream(createSourceStream, handleChunk2, controller),
+      retryOptions
+    ).catch((error2) => {
+      controller.error(error2);
+    });
+  }
+});
+var onRestream = async (createSourceStream, handleChunk2, controller) => {
+  const sourceStream = createSourceStream();
+  const reader = sourceStream.getReader();
+  try {
+    let done;
+    do {
+      const result = await reader.read();
+      done = result.done;
+      await handleChunk2(result, controller);
+      if (done) {
+        controller.terminate();
+      }
+    } while (!done);
+  } finally {
+    reader.releaseLock();
+  }
+};
+var skip = (limit) => new SkipTransformStream(limit);
+var SkipTransformStream = class extends TransformStream7 {
+  count = 0;
+  skip;
+  constructor(skip2) {
+    super({
+      transform: (chunk, controller) => {
+        this.count++;
+        if (this.count > this.skip) {
+          controller.enqueue(chunk);
+        }
+      }
+    });
+    this.skip = skip2;
+  }
+};
+var stopAfter = (stopCondition) => new TransformStream8({
+  transform(chunk, controller) {
+    controller.enqueue(chunk);
+    if (stopCondition(chunk)) {
+      controller.terminate();
+    }
+  }
+});
+var stopOn = (stopCondition) => new TransformStream9({
+  async transform(chunk, controller) {
+    if (!stopCondition(chunk)) {
+      controller.enqueue(chunk);
+      return;
+    }
+    await Promise.resolve();
+    controller.terminate();
+  }
+});
+var take = (limit) => new TakeTransformStream(limit);
+var TakeTransformStream = class extends TransformStream10 {
+  count = 0;
+  limit;
+  constructor(limit) {
+    super({
+      transform: (chunk, controller) => {
+        if (this.count < this.limit) {
+          this.count++;
+          controller.enqueue(chunk);
+        } else {
+          controller.terminate();
+        }
+      }
+    });
+    this.limit = limit;
+  }
+};
+var waitAtMost = (waitTimeInMs) => new TransformStream11({
+  start(controller) {
+    const timeoutId = setTimeout(() => {
+      controller.terminate();
+    }, waitTimeInMs);
+    const originalTerminate = controller.terminate.bind(controller);
+    controller.terminate = () => {
+      clearTimeout(timeoutId);
+      originalTerminate();
+    };
+  },
+  transform(chunk, controller) {
+    controller.enqueue(chunk);
+  }
+});
+var streamTransformations = {
+  filter,
+  take,
+  TakeTransformStream,
+  skip,
+  SkipTransformStream,
+  map,
+  notifyAboutNoActiveReadersStream,
+  NotifyAboutNoActiveReadersStream,
+  reduce,
+  ReduceTransformStream,
+  retry: retryStream,
+  stopAfter,
+  stopOn,
+  waitAtMost
+};
+var { retry: retry2 } = streamTransformations;
+var AssertionError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+var isSubset = (superObj, subObj) => {
+  const sup = superObj;
+  const sub = subObj;
+  assertOk(sup);
+  assertOk(sub);
+  return Object.keys(sub).every((ele) => {
+    if (typeof sub[ele] == "object") {
+      return isSubset(sup[ele], sub[ele]);
+    }
+    return sub[ele] === sup[ele];
+  });
+};
+var assertFails = (message) => {
+  throw new AssertionError(message ?? "That should not ever happened, right?");
+};
+var assertMatches = (actual, expected, message) => {
+  if (!isSubset(actual, expected))
+    throw new AssertionError(
+      message ?? `subObj:
+${JSONParser.stringify(expected)}
 is not subset of
-${u.stringify(e)}`)};function R(e,t){if(!e)throw new d(t??"Condition is not truthy")}function I(e,t,r){if(e!==t)throw new d(`${r??"Objects are not equal"}:
-Expected: ${u.stringify(e)}
-Actual:${u.stringify(t)}`)}var g=e=>{let t=new Map;return{async aggregateStream(r,s){return e.aggregateStream(r,s)},readStream(r,s){return e.readStream(r,s)},appendToStream:async(r,s,o)=>{let n=await e.appendToStream(r,s,o),c=t.get(r)??[r,[]];return t.set(r,[r,[...c[1],...s]]),n},appendedEvents:t,setup:async(r,s)=>e.appendToStream(r,s)}};import{ProblemDocument as ce}from"http-problem-details";var P=e=>(t,r,s,o)=>{let n;e&&(n=e(t,r)),n=n??le(t),h(s,n.status,{problem:n})},le=e=>{let t=500;return"errorCode"in e&&y(e.errorCode)&&e.errorCode>=100&&e.errorCode<600&&(t=e.errorCode),new ce({detail:e.message,status:t})};var Rt=e=>{let t=v(),{apis:r,mapError:s,enableDefaultExpressEtag:o,disableJsonMiddleware:n,disableUrlEncodingMiddleware:c,disableProblemDetailsMiddleware:a}=e,i=me();t.set("etag",o??!1),n||t.use(v.json()),c||t.use(v.urlencoded({extended:!0}));for(let p of r)p(i);return t.use(i),a||t.use(P(s)),t},xt=(e,t={port:3e3})=>{let{port:r}=t,s=ue.createServer(e);return s.on("listening",()=>{console.info("server up listening")}),s.listen(r)};var T={IF_MATCH:"if-match",IF_NOT_MATCH:"if-not-match",ETag:"etag"},_=/W\/"(-?\d+.*)"/,de=(s=>(s.WRONG_WEAK_ETAG_FORMAT="WRONG_WEAK_ETAG_FORMAT",s.MISSING_IF_MATCH_HEADER="MISSING_IF_MATCH_HEADER",s.MISSING_IF_NOT_MATCH_HEADER="MISSING_IF_NOT_MATCH_HEADER",s))(de||{}),fe=e=>_.test(e),ge=e=>{let t=_.exec(e);if(t===null||t.length===0)throw new Error("WRONG_WEAK_ETAG_FORMAT");return t[1]},Ct=e=>`W/"${e}"`,he=e=>{let t=e.headers[T.IF_MATCH];if(t===void 0)throw new Error("MISSING_IF_MATCH_HEADER");return t},Nt=e=>{let t=e.headers[T.IF_NOT_MATCH];if(t===void 0)throw new Error("MISSING_IF_MATCH_HEADER");return Array.isArray(t)?t[0]:t},S=(e,t)=>{e.setHeader(T.ETag,t)},It=e=>{let t=he(e);return fe(t)?ge(t):t};import"express";var Ht=e=>async(t,r,s)=>(await Promise.resolve(e(t)))(r),kt=e=>t=>{m(t,200,e)},Dt=e=>t=>{M(t,e)},qt=e=>t=>{H(t,e)},Vt=e=>ye(204,e),ye=(e,t)=>r=>{m(r,e,t)},Ft=e=>l(400,e),jt=e=>l(403,e),Bt=e=>l(404,e),$t=e=>l(409,e),Wt=e=>l(412,e),l=(e,t)=>r=>{h(r,e,t)};import"express";import{ProblemDocument as Ee}from"http-problem-details";var ve={},Te={problemDetails:"Error occured!"},M=(e,{eTag:t,...r})=>m(e,201,{location:"url"in r?r.url:`${e.req.url}/${r.createdId}`,body:"createdId"in r?{id:r.createdId}:void 0,eTag:t}),H=(e,t)=>m(e,202,t),m=(e,t,r)=>{let{location:s,body:o,eTag:n}=r??ve;n&&S(e,n),s&&e.setHeader("Location",s),o?(e.statusCode=t,e.send(o)):e.sendStatus(t)},h=(e,t,r)=>{r=r??Te;let{location:s,eTag:o}=r,n="problem"in r?r.problem:new Ee({detail:r.problemDetails,status:t});o&&S(e,o),s&&e.setHeader("Location",s),e.setHeader("Content-Type","application/problem+json"),e.statusCode=t,e.json(n)};import k from"supertest";import Se from"assert";var zt={for:(e,t)=>(...r)=>{let s=g(e()),o=t(s);return{when:n=>{let c=async()=>{for(let a of r)await a(k(o));return n(k(o))};return{then:async a=>{let i=await c();a.forEach(p=>{p(i)===!1&&Se.fail()})}}}}}};import"express";import be from"supertest";var sr=(e,t)=>[e,t],or=(e,t)=>[e,t],nr=(e,t)=>[e,t],we=(e,t)=>r=>{let{body:s,headers:o}=t??{};I(e,r.statusCode,"Response code doesn't match"),s&&f(r.body,s),o&&f(r.headers,o)},ar=(e,t)=>we(e,t?{body:t}:void 0),ir={for:(e,t)=>(...r)=>{let s=g(e()),o=t(s);return{when:n=>{let c=async()=>{for(let[a,i]of r)await s.setup(a,i);return n(be(o))};return{then:async a=>{let i=await c();if(typeof a=="function")a(i)===!1&&E();else if(Array.isArray(a)){let[p,...b]=a;typeof p=="function"&&p(i)===!1&&E();let D=typeof p=="function"?b:a;f(Array.from(s.appendedEvents.values()),D)}}}}}}};export{qt as Accepted,zt as ApiE2ESpecification,ir as ApiSpecification,Ft as BadRequest,$t as Conflict,Dt as Created,Te as DefaultHttpProblemResponseOptions,ve as DefaultHttpResponseOptions,de as ETagErrors,jt as Forbidden,T as HeaderNames,l as HttpProblem,ye as HttpResponse,Vt as NoContent,Bt as NotFound,kt as OK,Wt as PreconditionFailed,_ as WeakETagRegex,sr as existingStream,or as expect,ar as expectError,nr as expectNewEvents,we as expectResponse,Rt as getApplication,he as getETagFromIfMatch,Nt as getETagFromIfNotMatch,It as getETagValueFromIfMatch,ge as getWeakETagValue,fe as isWeakETag,Ht as on,m as send,H as sendAccepted,M as sendCreated,h as sendProblem,S as setETag,xt as startAPI,Ct as toWeakETag};
+${JSONParser.stringify(actual)}`
+    );
+};
+function assertOk(obj, message) {
+  if (!obj) throw new AssertionError(message ?? `Condition is not truthy`);
+}
+function assertEqual(expected, actual, message) {
+  if (expected !== actual)
+    throw new AssertionError(
+      `${message ?? "Objects are not equal"}:
+Expected: ${JSONParser.stringify(expected)}
+Actual:${JSONParser.stringify(actual)}`
+    );
+}
+var WrapEventStore = (eventStore) => {
+  const appendedEvents = /* @__PURE__ */ new Map();
+  return {
+    async aggregateStream(streamName, options) {
+      return eventStore.aggregateStream(streamName, options);
+    },
+    readStream(streamName, options) {
+      return 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();
+    // },
+  };
+};
+
+// src/middlewares/problemDetailsMiddleware.ts
+import { ProblemDocument } from "http-problem-details";
+var problemDetailsMiddleware = (mapError) => (error, request, response, _next) => {
+  let problemDetails;
+  if (mapError) problemDetails = mapError(error, request);
+  problemDetails = problemDetails ?? defaulErrorToProblemDetailsMapping(error);
+  sendProblem(response, problemDetails.status, { problem: problemDetails });
+};
+var defaulErrorToProblemDetailsMapping = (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/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);
+};
+
+// 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);
+};
+var getWeakETagValue = (etag) => {
+  const result = WeakETagRegex.exec(etag);
+  if (result === null || result.length === 0) {
+    throw new Error("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 Error("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 Error("MISSING_IF_MATCH_HEADER" /* MISSING_IF_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;
+};
+
+// src/handler.ts
+import "express";
+var on = (handle) => async (request, response, _next) => {
+  const setResponse = await Promise.resolve(handle(request));
+  return setResponse(response);
+};
+var OK = (options) => (response) => {
+  send(response, 200, options);
+};
+var Created = (options) => (response) => {
+  sendCreated(response, options);
+};
+var Accepted = (options) => (response) => {
+  sendAccepted(response, options);
+};
+var NoContent = (options) => HttpResponse(204, options);
+var 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);
+};
+
+// src/responses.ts
+import "express";
+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
+});
+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);
+};
+
+// src/testing/apiE2ESpecification.ts
+import supertest from "supertest";
+import assert from "assert";
+var ApiE2ESpecification = {
+  for: (getEventStore, getApplication2) => {
+    {
+      return (...givenRequests) => {
+        const eventStore = WrapEventStore(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();
+                });
+              }
+            };
+          }
+        };
+      };
+    }
+  }
+};
+
+// src/testing/apiSpecification.ts
+import "express";
+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
+};
 //# sourceMappingURL=index.js.map