@event-driven-io/emmett-postgresql 0.20.2-alpha2 → 0.20.2

package/dist/index.cjs

@@ -1,9 +1,813 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;var _dumbo = require('@event-driven-io/dumbo');var k=t=>typeof t=="number"&&t===t,W=t=>typeof t=="string";var M=t=>typeof t=="function"&&t.prototype&&t.prototype.constructor===t,H=class q extends Error{constructor(e){let n=e&&typeof e=="object"&&"errorCode"in e?e.errorCode:k(e)?e:500,o=e&&typeof e=="object"&&"message"in e?e.message:W(e)?e:`Error with status code '${n}' ocurred during Emmett processing`;super(o),this.errorCode=n,Object.setPrototypeOf(this,q.prototype)}},z=class Y extends H{constructor(e,n,o){super({errorCode:412,message:_nullishCoalesce(o, () => (`Expected version ${n.toString()} does not match current ${_optionalChain([e, 'optionalAccess', _2 => _2.toString, 'call', _3 => _3()])}`))}),this.current=e,this.expected=n,Object.setPrototypeOf(this,Y.prototype)}};var _uuid = require('uuid');var _webstreamspolyfill = require('web-streams-polyfill');var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);var J=(t,e,n)=>({type:t,data:e,metadata:n});var F="STREAM_EXISTS",U="STREAM_DOES_NOT_EXIST",N="NO_CONCURRENCY_CHECK",Re=(t,e,n)=>e===N?!0:e==U?t===n:e==F?t!==n:t===e,K=(t,e,n)=>{if(e??=N,!Re(t,e,n))throw new $(t,e)},$=class Z extends z{constructor(e,n){super(_optionalChain([e, 'optionalAccess', _4 => _4.toString, 'call', _5 => _5()]),_optionalChain([n, 'optionalAccess', _6 => _6.toString, 'call', _7 => _7()])),Object.setPrototypeOf(this,Z.prototype)}};var De=(t,e={})=>new ee(t,e),ee= (_class =class extends _webstreamspolyfill.TransformStream{constructor(t,e={}){super({cancel:n=>{console.log("Stream was canceled. Reason:",n),this.stopChecking()}});_class.prototype.__init.call(this);_class.prototype.__init2.call(this);,this.onNoActiveReaderCallback=t,this.streamId=_nullishCoalesce(_optionalChain([e, 'optionalAccess', _8 => _8.streamId]), () => (_uuid.v4.call(void 0, ))),this.onNoActiveReaderCallback=t,this.startChecking(_nullishCoalesce(_optionalChain([e, 'optionalAccess', _9 => _9.intervalCheckInMs]), () => (20)))}__init() {this.checkInterval=null}__init2() {this._isStopped=!1}get hasActiveSubscribers(){return!this._isStopped}startChecking(t){this.checkInterval=setInterval(()=>{this.checkNoActiveReader()},t)}stopChecking(){this.checkInterval&&(clearInterval(this.checkInterval),this.checkInterval=null,this._isStopped=!0,this.onNoActiveReaderCallback(this))}checkNoActiveReader(){!this.readable.locked&&!this._isStopped&&this.stopChecking()}}, _class);var T=(t,e)=>{if(xe(t))return t.equals(e);if(Array.isArray(t))return Array.isArray(e)&&t.length===e.length&&t.every((a,r)=>T(a,e[r]));if(typeof t!="object"||typeof e!="object"||t===null||e===null)return t===e;if(Array.isArray(e))return!1;let n=Object.keys(t),o=Object.keys(e);if(n.length!==o.length||!n.every(a=>o.includes(a)))return!1;for(let a in t){if(t[a]instanceof Function&&e[a]instanceof Function)continue;if(!T(t[a],e[a]))return!1}return!0},xe=t=>t&&typeof t=="object"&&"equals"in t&&typeof t.equals=="function";var Ce=async(t,e)=>e===void 0||e.retries===0?t():_asyncretry2.default.call(void 0, async n=>{try{return await t()}catch(o){throw _optionalChain([e, 'optionalAccess', _10 => _10.shouldRetryError])&&!e.shouldRetryError(o)&&n(o),o}},_nullishCoalesce(e, () => ({retries:0})));var te=t=>t;var be=class extends Error{constructor(t){super(`Cannot parse! ${t}`)}},h={stringify:(t,e)=>JSON.stringify(_optionalChain([e, 'optionalAccess', _11 => _11.map])?e.map(t):t,(n,o)=>typeof o=="bigint"?o.toString():o),parse:(t,e)=>{let n=JSON.parse(t,_optionalChain([e, 'optionalAccess', _12 => _12.reviver]));if(_optionalChain([e, 'optionalAccess', _13 => _13.typeCheck])&&!_optionalChain([e, 'optionalAccess', _14 => _14.typeCheck, 'call', _15 => _15(n)]))throw new be(t);return _optionalChain([e, 'optionalAccess', _16 => _16.map])?e.map(n):n}};var Fe=t=>new (0, _webstreamspolyfill.TransformStream)({transform(e,n){t(e)&&n.enqueue(e)}}),$e=t=>new (0, _webstreamspolyfill.TransformStream)({transform(e,n){n.enqueue(t(e))}}),Qe=(t,e)=>new ne(t,e),ne=class extends _webstreamspolyfill.TransformStream{constructor(t,e){super({transform:n=>{this.accumulator=this.reducer(this.accumulator,n)},flush:n=>{n.enqueue(this.accumulator),n.terminate()}}),this.accumulator=e,this.reducer=t}},Xe=(t,e,n={forever:!0,minTimeout:25})=>new (0, _webstreamspolyfill.TransformStream)({start(o){Ce(()=>Ve(t,e,o),n).catch(a=>{o.error(a)})}}),Ve=async(t,e,n)=>{let a=t().getReader();try{let r;do{let l=await a.read();r=l.done,await e(l,n),r&&n.terminate()}while(!r)}finally{a.releaseLock()}},ke=t=>new oe(t),oe= (_class2 =class extends _webstreamspolyfill.TransformStream{__init3() {this.count=0}constructor(t){super({transform:(e,n)=>{this.count++,this.count>this.skip&&n.enqueue(e)}});_class2.prototype.__init3.call(this);,this.skip=t}}, _class2),He=t=>new (0, _webstreamspolyfill.TransformStream)({transform(e,n){n.enqueue(e),t(e)&&n.terminate()}}),ze=t=>new (0, _webstreamspolyfill.TransformStream)({async transform(e,n){if(!t(e)){n.enqueue(e);return}await Promise.resolve(),n.terminate()}}),Je=t=>new ae(t),ae= (_class3 =class extends _webstreamspolyfill.TransformStream{__init4() {this.count=0}constructor(t){super({transform:(e,n)=>{this.count<this.limit?(this.count++,n.enqueue(e)):n.terminate()}});_class3.prototype.__init4.call(this);,this.limit=t}}, _class3),Ze=t=>new (0, _webstreamspolyfill.TransformStream)({start(e){let n=setTimeout(()=>{e.terminate()},t),o=e.terminate.bind(e);e.terminate=()=>{clearTimeout(n),o()}},transform(e,n){n.enqueue(e)}}),et={filter:Fe,take:Je,TakeTransformStream:ae,skip:ke,SkipTransformStream:oe,map:$e,notifyAboutNoActiveReadersStream:De,NotifyAboutNoActiveReadersStream:ee,reduce:Qe,ReduceTransformStream:ne,retry:Xe,stopAfter:He,stopOn:ze,waitAtMost:Ze},{retry:rn}=et;var y=class extends Error{constructor(t){super(t)}};var re=t=>{throw new y(_nullishCoalesce(t, () => ("That should not ever happened, right?")))};var ie=(t,e,n)=>{if(!T(t,e))throw new y(_nullishCoalesce(n, () => (`subObj:
-${h.stringify(e)}
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;// src/eventStore/postgreSQLEventStore.ts
+
+
+var _dumbo = require('@event-driven-io/dumbo');
+
+// ../emmett/dist/chunk-AEEEXE2R.js
+var isNumber = (val) => typeof val === "number" && val === val;
+var isString = (val) => typeof val === "string";
+var isErrorConstructor = (expect) => {
+  return typeof expect === "function" && expect.prototype && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  expect.prototype.constructor === expect;
+};
+var EmmettError = class _EmmettError extends Error {
+  
+  constructor(options) {
+    const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : 500;
+    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);
+  }
+};
+var ConcurrencyError = class _ConcurrencyError extends EmmettError {
+  constructor(current, expected, message) {
+    super({
+      errorCode: 412,
+      message: _nullishCoalesce(message, () => ( `Expected version ${expected.toString()} does not match current ${_optionalChain([current, 'optionalAccess', _2 => _2.toString, 'call', _3 => _3()])}`))
+    });
+    this.current = current;
+    this.expected = expected;
+    Object.setPrototypeOf(this, _ConcurrencyError.prototype);
+  }
+};
+
+// ../emmett/dist/index.js
+var _uuid = require('uuid');
+var _webstreamspolyfill = require('web-streams-polyfill');
+
+
+
+var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
+
+
+
+
+
+
+
+
+
+
+
+
+
+var event = (type, data, metadata) => {
+  return {
+    type,
+    data,
+    metadata
+  };
+};
+var STREAM_EXISTS = "STREAM_EXISTS";
+var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
+var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
+var matchesExpectedVersion = (current, expected, defaultVersion) => {
+  if (expected === NO_CONCURRENCY_CHECK) return true;
+  if (expected == STREAM_DOES_NOT_EXIST) return current === defaultVersion;
+  if (expected == STREAM_EXISTS) return current !== defaultVersion;
+  return current === expected;
+};
+var assertExpectedVersionMatchesCurrent = (current, expected, defaultVersion) => {
+  expected ??= NO_CONCURRENCY_CHECK;
+  if (!matchesExpectedVersion(current, expected, defaultVersion))
+    throw new ExpectedVersionConflictError(current, expected);
+};
+var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends ConcurrencyError {
+  constructor(current, expected) {
+    super(_optionalChain([current, 'optionalAccess', _4 => _4.toString, 'call', _5 => _5()]), _optionalChain([expected, 'optionalAccess', _6 => _6.toString, 'call', _7 => _7()]));
+    Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
+  }
+};
+var notifyAboutNoActiveReadersStream = (onNoActiveReaderCallback, options = {}) => new NotifyAboutNoActiveReadersStream(onNoActiveReaderCallback, options);
+var NotifyAboutNoActiveReadersStream = (_class = class extends _webstreamspolyfill.TransformStream {
+  constructor(onNoActiveReaderCallback, options = {}) {
+    super({
+      cancel: (reason) => {
+        console.log("Stream was canceled. Reason:", reason);
+        this.stopChecking();
+      }
+    });_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;
+    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
+    this.streamId = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.streamId]), () => ( _uuid.v4.call(void 0, )));
+    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
+    this.startChecking(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _9 => _9.intervalCheckInMs]), () => ( 20)));
+  }
+  __init() {this.checkInterval = null}
+  
+  __init2() {this._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();
+    }
+  }
+}, _class);
+var deepEquals = (left, right) => {
+  if (isEquatable(left)) {
+    return left.equals(right);
+  }
+  if (Array.isArray(left)) {
+    return Array.isArray(right) && left.length === right.length && left.every((val, index) => deepEquals(val, right[index]));
+  }
+  if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) {
+    return left === right;
+  }
+  if (Array.isArray(right)) return false;
+  const keys1 = Object.keys(left);
+  const keys2 = Object.keys(right);
+  if (keys1.length !== keys2.length || !keys1.every((key) => keys2.includes(key)))
+    return false;
+  for (const key in left) {
+    if (left[key] instanceof Function && right[key] instanceof Function)
+      continue;
+    const isEqual = deepEquals(left[key], right[key]);
+    if (!isEqual) {
+      return false;
+    }
+  }
+  return true;
+};
+var isEquatable = (left) => {
+  return left && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
+};
+var asyncRetry = async (fn, opts) => {
+  if (opts === void 0 || opts.retries === 0) return fn();
+  return _asyncretry2.default.call(void 0, 
+    async (bail) => {
+      try {
+        return await fn();
+      } catch (error2) {
+        if (_optionalChain([opts, 'optionalAccess', _10 => _10.shouldRetryError]) && !opts.shouldRetryError(error2)) {
+          bail(error2);
+        }
+        throw error2;
+      }
+    },
+    _nullishCoalesce(opts, () => ( { retries: 0 }))
+  );
+};
+var projection = (definition) => definition;
+var ParseError = class extends Error {
+  constructor(text) {
+    super(`Cannot parse! ${text}`);
+  }
+};
+var JSONParser = {
+  stringify: (value, options) => {
+    return JSON.stringify(
+      _optionalChain([options, 'optionalAccess', _11 => _11.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, _optionalChain([options, 'optionalAccess', _12 => _12.reviver]));
+    if (_optionalChain([options, 'optionalAccess', _13 => _13.typeCheck]) && !_optionalChain([options, 'optionalAccess', _14 => _14.typeCheck, 'call', _15 => _15(parsed)]))
+      throw new ParseError(text);
+    return _optionalChain([options, 'optionalAccess', _16 => _16.map]) ? options.map(parsed) : parsed;
+  }
+};
+var filter = (filter2) => new (0, _webstreamspolyfill.TransformStream)({
+  transform(chunk, controller) {
+    if (filter2(chunk)) {
+      controller.enqueue(chunk);
+    }
+  }
+});
+var map = (map2) => new (0, _webstreamspolyfill.TransformStream)({
+  transform(chunk, controller) {
+    controller.enqueue(map2(chunk));
+  }
+});
+var reduce = (reducer, initialValue) => new ReduceTransformStream(reducer, initialValue);
+var ReduceTransformStream = class extends _webstreamspolyfill.TransformStream {
+  
+  
+  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 (0, _webstreamspolyfill.TransformStream)({
+  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 = (_class2 = class extends _webstreamspolyfill.TransformStream {
+  __init3() {this.count = 0}
+  
+  constructor(skip2) {
+    super({
+      transform: (chunk, controller) => {
+        this.count++;
+        if (this.count > this.skip) {
+          controller.enqueue(chunk);
+        }
+      }
+    });_class2.prototype.__init3.call(this);;
+    this.skip = skip2;
+  }
+}, _class2);
+var stopAfter = (stopCondition) => new (0, _webstreamspolyfill.TransformStream)({
+  transform(chunk, controller) {
+    controller.enqueue(chunk);
+    if (stopCondition(chunk)) {
+      controller.terminate();
+    }
+  }
+});
+var stopOn = (stopCondition) => new (0, _webstreamspolyfill.TransformStream)({
+  async transform(chunk, controller) {
+    if (!stopCondition(chunk)) {
+      controller.enqueue(chunk);
+      return;
+    }
+    await Promise.resolve();
+    controller.terminate();
+  }
+});
+var take = (limit) => new TakeTransformStream(limit);
+var TakeTransformStream = (_class3 = class extends _webstreamspolyfill.TransformStream {
+  __init4() {this.count = 0}
+  
+  constructor(limit) {
+    super({
+      transform: (chunk, controller) => {
+        if (this.count < this.limit) {
+          this.count++;
+          controller.enqueue(chunk);
+        } else {
+          controller.terminate();
+        }
+      }
+    });_class3.prototype.__init4.call(this);;
+    this.limit = limit;
+  }
+}, _class3);
+var waitAtMost = (waitTimeInMs) => new (0, _webstreamspolyfill.TransformStream)({
+  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 assertFails = (message) => {
+  throw new AssertionError(_nullishCoalesce(message, () => ( "That should not ever happened, right?")));
+};
+var assertDeepEqual = (actual, expected, message) => {
+  if (!deepEquals(actual, expected))
+    throw new AssertionError(
+      _nullishCoalesce(message, () => ( `subObj:
+${JSONParser.stringify(expected)}
 is not equal to
-${h.stringify(t)}`)))};function _(t,e){if(!t)throw new y(_nullishCoalesce(e, () => ("Condition is false")))}function tt(t,e){if(!t)throw new y(_nullishCoalesce(e, () => ("Condition is not truthy")))}function S(t,e,n){if(t!==e)throw new y(`${_nullishCoalesce(n, () => ("Objects are not equal"))}:
-Expected: ${h.stringify(t)}
-Actual:${h.stringify(e)}`)}function se(t,e,n){if(t===e)throw new y(_nullishCoalesce(n, () => (`Objects are equal: ${h.stringify(t)}`)))}function j(t){se(t,null),tt(t)}var R=t=>({isEmpty:()=>S(t.length,0),isNotEmpty:()=>se(t.length,0),hasSize:e=>S(t.length,e),containsElements:(...e)=>{_(e.every(n=>e.some(o=>T(n,o))))},containsExactlyInAnyOrder:(...e)=>{S(t.length,e.length),_(t.every(n=>e.some(o=>T(n,o))))},containsExactlyInAnyOrderElementsOf:e=>{S(t.length,e.length),_(t.every(n=>e.some(o=>T(n,o))))},containsExactlyElementsOf:e=>{S(t.length,e.length);for(let n=0;n<t.length;n++)_(T(t[n],e[n]))},containsExactly:e=>{S(t.length,1),_(T(t[0],e))},contains:e=>{_(t.some(n=>T(n,e)))},containsOnlyOnceElementsOf:e=>{_(e.map(n=>t.filter(o=>T(o,n)).length).filter(n=>n===1).length===e.length)},containsAnyOf:(...e)=>{_(t.some(n=>e.some(o=>T(n,o))))},allMatch:e=>{_(t.every(e))},anyMatches:e=>{_(t.some(e))},allMatchAsync:async e=>{for(let n of t)_(await e(n))}});require('pg');var _pongo = require('@event-driven-io/pongo');var A=(t,e)=>{let{pool:n,connectionString:o,inDatabase:a,inCollection:r}=e;return n.withConnection(async l=>{let m=_pongo.pongoClient.call(void 0, o,{connectionOptions:{connection:l}});try{let p=m.db(a).collection(r);return t(p)}finally{await m.close()}})},ce=t=>{let{_id:e,_version:n,...o}=t;return o},ot=(t,e)=>("_id"in e&&S(e._id,t._id,`Document ids are not matching! Expected: ${e._id}, actual: ${t._id}`),ie(ce(t),ce(e))),at= exports.documentExists =(t,e)=>n=>A(async o=>{let a=await o.findOne("withId"in e?{_id:e.withId}:e.matchingFilter);j(a),ot(a,t)},{...e,...n}),rt= exports.documentsAreTheSame =(t,e)=>n=>A(async o=>{let a=await o.find("withId"in e?{_id:e.withId}:e.matchingFilter);S(t.length,a.length,"Different Documents Count than expected");for(let r=0;r<t.length;r++)R(a).contains(t[r])},{...e,...n}),it= exports.documentsMatchingHaveCount =(t,e)=>n=>A(async o=>{let a=await o.find("withId"in e?{_id:e.withId}:e.matchingFilter);S(t,a.length,"Different Documents Count than expected")},{...e,...n}),me= exports.documentMatchingExists =t=>e=>A(async n=>{let o=await n.find("withId"in t?{_id:t.withId}:t.matchingFilter);R(o).isNotEmpty()},{...t,...e}),de= exports.documentDoesNotExist =t=>e=>A(async n=>{let o=await n.findOne("withId"in t?{_id:t.withId}:t.matchingFilter);j(o)},{...t,...e}),gn= exports.expectPongoDocuments ={fromCollection:t=>({withId:e=>({toBeEqual:n=>at(n,{withId:e,inCollection:t}),toExist:()=>me({withId:e,inCollection:t}),notToExist:()=>de({withId:e,inCollection:t})}),matching:e=>({toBeTheSame:n=>rt(n,{matchingFilter:e,inCollection:t}),toHaveCount:n=>it(n,{matchingFilter:e,inCollection:t}),toExist:()=>me({matchingFilter:e,inCollection:t}),notToExist:()=>de({matchingFilter:e,inCollection:t})})})};var ct=({handle:t,canHandle:e})=>Q({canHandle:e,handle:async(n,o)=>{let{connectionString:a,client:r}=o,l=_pongo.pongoClient.call(void 0, a,{connectionOptions:{client:r}});await t(n,{...o,pongo:l})}}),mt= exports.pongoMultiStreamProjection =t=>{let{collectionName:e,getDocumentId:n,canHandle:o}=t;return ct({handle:async(a,{pongo:r})=>{let l=r.db().collection(e);for(let m of a)await l.handle(n(m),async p=>"initialState"in t?await t.evolve(_nullishCoalesce(p, () => (t.initialState())),m):await t.evolve(p,m))},canHandle:o})},Pn= exports.pongoSingleStreamProjection =t=>mt({...t,getDocumentId:e=>e.metadata.streamName});var wn={for:t=>{{let{projection:e,...n}=t,{connectionString:o}=n;return a=>({when:(r,l)=>{let m=[],p=async c=>{let E=0n,d=_nullishCoalesce(_optionalChain([l, 'optionalAccess', _17 => _17.numberOfTimes]), () => (1));for(let v of[...a,...Array.from({length:d}).flatMap(()=>r)])m.push({...v,metadata:{globalPosition:++E,streamPosition:E,streamName:`test-${_uuid.v4.call(void 0, )}`,eventId:_uuid.v4.call(void 0, ),..._nullishCoalesce(v.metadata, () => ({}))}});await c.withTransaction(v=>D({events:m,projections:[e],connection:{connectionString:o,transaction:v}}))};return{then:async(c,E)=>{let d=_dumbo.dumbo.call(void 0, n);try{await p(d);let v=await c({pool:d,connectionString:o});v!==void 0&&v===!1&&re(_nullishCoalesce(E, () => ("Projection specification didn't match the criteria")))}finally{await d.close()}},thenThrows:async(...c)=>{let E=_dumbo.dumbo.call(void 0, n);try{throw await p(E),new y("Handler did not fail as expected")}catch(d){if(d instanceof y)throw d;if(c.length===0)return;if(!M(c[0])){_(c[0](d),`Error didn't match the error condition: ${_optionalChain([d, 'optionalAccess', _18 => _18.toString, 'call', _19 => _19()])}`);return}_(d instanceof c[0],`Caught error is not an instance of the expected type: ${_optionalChain([d, 'optionalAccess', _20 => _20.toString, 'call', _21 => _21()])}`),c[1]&&_(c[1](d),`Error didn't match the error condition: ${_optionalChain([d, 'optionalAccess', _22 => _22.toString, 'call', _23 => _23()])}`)}finally{await E.close()}}}}})}}},dt= exports.eventInStream =(t,e)=>({...e,metadata:{..._nullishCoalesce(e.metadata, () => ({})),streamName:_nullishCoalesce(_optionalChain([e, 'access', _24 => _24.metadata, 'optionalAccess', _25 => _25.streamName]), () => (t))}}),lt= exports.eventsInStream =(t,e)=>e.map(n=>dt(t,n)),Cn= exports.newEventsInStream =lt,Et= exports.assertSQLQueryResultMatches =(t,e)=>async({pool:{execute:n}})=>{let o=await n.query(t);R(e).containsExactlyInAnyOrder(...o.rows)},bn= exports.expectSQL ={query:t=>({resultRows:{toBeTheSame:e=>Et(t,e)}})};var D=async t=>{let{projections:e,events:n,connection:{transaction:o,connectionString:a}}=t,r=n.map(p=>p.type),l=e.filter(p=>p.canHandle.some(c=>r.includes(c))),m=await o.connection.open();for(let p of l)await p.handle(n,{connectionString:a,client:m,transaction:o,execute:o.execute})},Q= exports.postgreSQLProjection =t=>te(t),pt= exports.postgreSQLRawBatchSQLProjection =(t,...e)=>Q({canHandle:e,handle:async(n,o)=>{let a=await t(n,o);await o.execute.batchCommand(a)}}),$n= exports.postgreSQLRawSQLProjection =(t,...e)=>pt(async(n,o)=>{let a=[];for(let r of n)a.push(await t(r,o));return a},...e);var x="emt",u= exports.globalTag ="global",O= exports.defaultTag ="emt:default",Xn= exports.globalNames ={module:`${x}:module:${u}`,tenant:`${x}:tenant:${u}`},w={partition:{name:"partition"},isArchived:{name:"is_archived"}},s= exports.streamsTable ={name:`${x}_streams`,columns:{partition:w.partition,isArchived:w.isArchived}},i= exports.eventsTable ={name:`${x}_events`,columns:{partition:w.partition,isArchived:w.isArchived}};var pe=_dumbo.rawSql.call(void 0, `CREATE OR REPLACE FUNCTION emt_append_event(
+${JSONParser.stringify(actual)}`))
+    );
+};
+function assertTrue(condition, message) {
+  if (!condition) throw new AssertionError(_nullishCoalesce(message, () => ( `Condition is false`)));
+}
+function assertOk(obj, message) {
+  if (!obj) throw new AssertionError(_nullishCoalesce(message, () => ( `Condition is not truthy`)));
+}
+function assertEqual(expected, actual, message) {
+  if (expected !== actual)
+    throw new AssertionError(
+      `${_nullishCoalesce(message, () => ( "Objects are not equal"))}:
+Expected: ${JSONParser.stringify(expected)}
+Actual:${JSONParser.stringify(actual)}`
+    );
+}
+function assertNotEqual(obj, other, message) {
+  if (obj === other)
+    throw new AssertionError(
+      _nullishCoalesce(message, () => ( `Objects are equal: ${JSONParser.stringify(obj)}`))
+    );
+}
+function assertIsNotNull(result) {
+  assertNotEqual(result, null);
+  assertOk(result);
+}
+var assertThatArray = (array) => {
+  return {
+    isEmpty: () => assertEqual(array.length, 0),
+    isNotEmpty: () => assertNotEqual(array.length, 0),
+    hasSize: (length) => assertEqual(array.length, length),
+    containsElements: (...other) => {
+      assertTrue(other.every((ts) => other.some((o) => deepEquals(ts, o))));
+    },
+    containsExactlyInAnyOrder: (...other) => {
+      assertEqual(array.length, other.length);
+      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
+    },
+    containsExactlyInAnyOrderElementsOf: (other) => {
+      assertEqual(array.length, other.length);
+      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
+    },
+    containsExactlyElementsOf: (other) => {
+      assertEqual(array.length, other.length);
+      for (let i = 0; i < array.length; i++) {
+        assertTrue(deepEquals(array[i], other[i]));
+      }
+    },
+    containsExactly: (elem) => {
+      assertEqual(array.length, 1);
+      assertTrue(deepEquals(array[0], elem));
+    },
+    contains: (elem) => {
+      assertTrue(array.some((a) => deepEquals(a, elem)));
+    },
+    containsOnlyOnceElementsOf: (other) => {
+      assertTrue(
+        other.map((o) => array.filter((a) => deepEquals(a, o)).length).filter((a) => a === 1).length === other.length
+      );
+    },
+    containsAnyOf: (...other) => {
+      assertTrue(array.some((a) => other.some((o) => deepEquals(a, o))));
+    },
+    allMatch: (matches) => {
+      assertTrue(array.every(matches));
+    },
+    anyMatches: (matches) => {
+      assertTrue(array.some(matches));
+    },
+    allMatchAsync: async (matches) => {
+      for (const item of array) {
+        assertTrue(await matches(item));
+      }
+    }
+  };
+};
+
+// src/eventStore/postgreSQLEventStore.ts
+require('pg');
+
+// src/eventStore/projections/index.ts
+
+
+// src/eventStore/projections/pongo/pongoProjectionSpec.ts
+
+
+
+var _pongo = require('@event-driven-io/pongo');
+var withCollection = (handle, options) => {
+  const { pool, connectionString, inDatabase, inCollection } = options;
+  return pool.withConnection(async (connection) => {
+    const pongo = _pongo.pongoClient.call(void 0, connectionString, {
+      connectionOptions: { connection }
+    });
+    try {
+      const collection = pongo.db(inDatabase).collection(inCollection);
+      return handle(collection);
+    } finally {
+      await pongo.close();
+    }
+  });
+};
+var withoutIdAndVersion = (doc) => {
+  const { _id, _version, ...without } = doc;
+  return without;
+};
+var assertDocumentsEqual = (actual, expected) => {
+  if ("_id" in expected)
+    assertEqual(
+      expected._id,
+      actual._id,
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `Document ids are not matching! Expected: ${expected._id}, actual: ${actual._id}`
+    );
+  return assertDeepEqual(
+    withoutIdAndVersion(actual),
+    withoutIdAndVersion(expected)
+  );
+};
+var documentExists = (document, options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.findOne(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertIsNotNull(result);
+    assertDocumentsEqual(result, document);
+  },
+  { ...options, ...assertOptions }
+);
+var documentsAreTheSame = (documents, options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.find(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertEqual(
+      documents.length,
+      result.length,
+      "Different Documents Count than expected"
+    );
+    for (let i = 0; i < documents.length; i++) {
+      assertThatArray(result).contains(documents[i]);
+    }
+  },
+  { ...options, ...assertOptions }
+);
+var documentsMatchingHaveCount = (expectedCount, options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.find(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertEqual(
+      expectedCount,
+      result.length,
+      "Different Documents Count than expected"
+    );
+  },
+  { ...options, ...assertOptions }
+);
+var documentMatchingExists = (options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.find(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertThatArray(result).isNotEmpty();
+  },
+  { ...options, ...assertOptions }
+);
+var documentDoesNotExist = (options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.findOne(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertIsNotNull(result);
+  },
+  { ...options, ...assertOptions }
+);
+var expectPongoDocuments = {
+  fromCollection: (collectionName) => {
+    return {
+      withId: (id) => {
+        return {
+          toBeEqual: (document) => documentExists(document, {
+            withId: id,
+            inCollection: collectionName
+          }),
+          toExist: () => documentMatchingExists({
+            withId: id,
+            inCollection: collectionName
+          }),
+          notToExist: () => documentDoesNotExist({
+            withId: id,
+            inCollection: collectionName
+          })
+        };
+      },
+      matching: (filter2) => {
+        return {
+          toBeTheSame: (documents) => documentsAreTheSame(documents, {
+            matchingFilter: filter2,
+            inCollection: collectionName
+          }),
+          toHaveCount: (expectedCount) => documentsMatchingHaveCount(expectedCount, {
+            matchingFilter: filter2,
+            inCollection: collectionName
+          }),
+          toExist: () => documentMatchingExists({
+            matchingFilter: filter2,
+            inCollection: collectionName
+          }),
+          notToExist: () => documentDoesNotExist({
+            matchingFilter: filter2,
+            inCollection: collectionName
+          })
+        };
+      }
+    };
+  }
+};
+
+// src/eventStore/projections/pongo/projections.ts
+
+
+
+var pongoProjection = ({
+  handle,
+  canHandle
+}) => postgreSQLProjection({
+  canHandle,
+  handle: async (events, context) => {
+    const { connectionString, client } = context;
+    const pongo = _pongo.pongoClient.call(void 0, connectionString, {
+      connectionOptions: { client }
+    });
+    await handle(events, {
+      ...context,
+      pongo
+    });
+  }
+});
+var pongoMultiStreamProjection = (options) => {
+  const { collectionName, getDocumentId, canHandle } = options;
+  return pongoProjection({
+    handle: async (events, { pongo }) => {
+      const collection = pongo.db().collection(collectionName);
+      for (const event2 of events) {
+        await collection.handle(getDocumentId(event2), async (document) => {
+          return "initialState" in options ? await options.evolve(
+            _nullishCoalesce(document, () => ( options.initialState())),
+            event2
+          ) : await options.evolve(
+            document,
+            event2
+          );
+        });
+      }
+    },
+    canHandle
+  });
+};
+var pongoSingleStreamProjection = (options) => {
+  return pongoMultiStreamProjection({
+    ...options,
+    getDocumentId: (event2) => event2.metadata.streamName
+  });
+};
+
+// src/eventStore/projections/postgresProjectionSpec.ts
+
+
+
+
+var PostgreSQLProjectionSpec = {
+  for: (options) => {
+    {
+      const { projection: projection2, ...dumoOptions } = options;
+      const { connectionString } = dumoOptions;
+      return (givenEvents) => {
+        return {
+          when: (events, options2) => {
+            const allEvents = [];
+            const run = async (pool) => {
+              let globalPosition = 0n;
+              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _17 => _17.numberOfTimes]), () => ( 1));
+              for (const event2 of [
+                ...givenEvents,
+                ...Array.from({ length: numberOfTimes }).flatMap(() => events)
+              ]) {
+                allEvents.push({
+                  ...event2,
+                  metadata: {
+                    ...{
+                      globalPosition: ++globalPosition,
+                      streamPosition: globalPosition,
+                      streamName: `test-${_uuid.v4.call(void 0, )}`,
+                      eventId: _uuid.v4.call(void 0, )
+                    },
+                    ..._nullishCoalesce(event2.metadata, () => ( {}))
+                  }
+                });
+              }
+              await pool.withTransaction(
+                (transaction) => handleProjections({
+                  events: allEvents,
+                  projections: [projection2],
+                  connection: {
+                    connectionString,
+                    transaction
+                  }
+                })
+              );
+            };
+            return {
+              then: async (assert, message) => {
+                const pool = _dumbo.dumbo.call(void 0, dumoOptions);
+                try {
+                  await run(pool);
+                  const succeeded = await assert({ pool, connectionString });
+                  if (succeeded !== void 0 && succeeded === false)
+                    assertFails(
+                      _nullishCoalesce(message, () => ( "Projection specification didn't match the criteria"))
+                    );
+                } finally {
+                  await pool.close();
+                }
+              },
+              thenThrows: async (...args) => {
+                const pool = _dumbo.dumbo.call(void 0, dumoOptions);
+                try {
+                  await run(pool);
+                  throw new AssertionError("Handler did not fail as expected");
+                } catch (error) {
+                  if (error instanceof AssertionError) throw error;
+                  if (args.length === 0) return;
+                  if (!isErrorConstructor(args[0])) {
+                    assertTrue(
+                      args[0](error),
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _18 => _18.toString, 'call', _19 => _19()])}`
+                    );
+                    return;
+                  }
+                  assertTrue(
+                    error instanceof args[0],
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _20 => _20.toString, 'call', _21 => _21()])}`
+                  );
+                  if (args[1]) {
+                    assertTrue(
+                      args[1](error),
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _22 => _22.toString, 'call', _23 => _23()])}`
+                    );
+                  }
+                } finally {
+                  await pool.close();
+                }
+              }
+            };
+          }
+        };
+      };
+    }
+  }
+};
+var eventInStream = (streamName, event2) => {
+  return {
+    ...event2,
+    metadata: {
+      ..._nullishCoalesce(event2.metadata, () => ( {})),
+      streamName: _nullishCoalesce(_optionalChain([event2, 'access', _24 => _24.metadata, 'optionalAccess', _25 => _25.streamName]), () => ( streamName))
+    }
+  };
+};
+var eventsInStream = (streamName, events) => {
+  return events.map((e) => eventInStream(streamName, e));
+};
+var newEventsInStream = eventsInStream;
+var assertSQLQueryResultMatches = (sql3, rows) => async ({ pool: { execute } }) => {
+  const result = await execute.query(sql3);
+  assertThatArray(rows).containsExactlyInAnyOrder(...result.rows);
+};
+var expectSQL = {
+  query: (sql3) => ({
+    resultRows: {
+      toBeTheSame: (rows) => assertSQLQueryResultMatches(sql3, rows)
+    }
+  })
+};
+
+// src/eventStore/projections/index.ts
+var handleProjections = async (options) => {
+  const {
+    projections: allProjections,
+    events,
+    connection: { transaction, connectionString }
+  } = options;
+  const eventTypes = events.map((e) => e.type);
+  const projections = allProjections.filter(
+    (p) => p.canHandle.some((type) => eventTypes.includes(type))
+  );
+  const client = await transaction.connection.open();
+  for (const projection2 of projections) {
+    await projection2.handle(events, {
+      connectionString,
+      client,
+      transaction,
+      execute: transaction.execute
+    });
+  }
+};
+var postgreSQLProjection = (definition) => projection(definition);
+var postgreSQLRawBatchSQLProjection = (handle, ...canHandle) => postgreSQLProjection({
+  canHandle,
+  handle: async (events, context) => {
+    const sqls = await handle(events, context);
+    await context.execute.batchCommand(sqls);
+  }
+});
+var postgreSQLRawSQLProjection = (handle, ...canHandle) => postgreSQLRawBatchSQLProjection(
+  async (events, context) => {
+    const sqls = [];
+    for (const event2 of events) {
+      sqls.push(await handle(event2, context));
+    }
+    return sqls;
+  },
+  ...canHandle
+);
+
+// src/eventStore/schema/index.ts
+
+
+// src/eventStore/schema/appendToStream.ts
+
+
+
+
+
+
+
+// src/eventStore/schema/typing.ts
+var emmettPrefix = "emt";
+var globalTag = "global";
+var defaultTag = "emt:default";
+var globalNames = {
+  module: `${emmettPrefix}:module:${globalTag}`,
+  tenant: `${emmettPrefix}:tenant:${globalTag}`
+};
+var columns = {
+  partition: {
+    name: "partition"
+  },
+  isArchived: { name: "is_archived" }
+};
+var streamsTable = {
+  name: `${emmettPrefix}_streams`,
+  columns: {
+    partition: columns.partition,
+    isArchived: columns.isArchived
+  }
+};
+var eventsTable = {
+  name: `${emmettPrefix}_events`,
+  columns: {
+    partition: columns.partition,
+    isArchived: columns.isArchived
+  }
+};
+
+// src/eventStore/schema/appendToStream.ts
+var appendEventsSQL = _dumbo.rawSql.call(void 0, 
+  `CREATE OR REPLACE FUNCTION emt_append_event(
       v_event_ids text[],
       v_events_data jsonb[],
       v_events_metadata jsonb[],
@@ -29,7 +833,7 @@ Actual:${h.stringify(e)}`)}function se(t,e,n){if(t===e)throw new y(_nullishCoale
   BEGIN
       IF v_expected_stream_position IS NULL THEN
           SELECT COALESCE(max(stream_position), 0) INTO v_expected_stream_position
-          FROM ${s.name}
+          FROM ${streamsTable.name}
           WHERE stream_id = v_stream_id AND partition = v_partition;
       END IF;
 
@@ -51,7 +855,7 @@ Actual:${h.stringify(e)}`)}function se(t,e,n){if(t===e)throw new y(_nullishCoale
           ) AS event
       ),
       all_events_insert AS (
-          INSERT INTO ${i.name}
+          INSERT INTO ${eventsTable.name}
               (stream_id, stream_position, partition, event_data, event_metadata, event_schema_version, event_type, event_id, transaction_id)
           SELECT 
               v_stream_id, ev.stream_position, v_partition, ev.event_data, ev.event_metadata, ev.schema_version, ev.event_type, ev.event_id, v_transaction_id
@@ -65,12 +869,12 @@ Actual:${h.stringify(e)}`)}function se(t,e,n){if(t===e)throw new y(_nullishCoale
 
 
       IF v_expected_stream_position = 0 THEN
-          INSERT INTO ${s.name}
+          INSERT INTO ${streamsTable.name}
               (stream_id, stream_position, partition, stream_type, stream_metadata, is_archived)
           VALUES
               (v_stream_id, v_next_stream_position, v_partition, v_stream_type, '{}', FALSE);
       ELSE
-          UPDATE ${s.name} as s              
+          UPDATE ${streamsTable.name} as s              
           SET stream_position = v_next_stream_position
           WHERE stream_id = v_stream_id AND stream_position = v_expected_stream_position AND partition = v_partition AND is_archived = FALSE;
 
@@ -85,7 +889,74 @@ Actual:${h.stringify(e)}`)}function se(t,e,n){if(t===e)throw new y(_nullishCoale
       RETURN QUERY SELECT TRUE, v_next_stream_position, v_last_global_position, v_transaction_id;
   END;
   $$;
-  `),ve= exports.appendToStream =(t,e,n,o,a)=>t.withTransaction(async r=>{let{execute:l}=r;if(o.length===0)return{success:!1,result:{success:!1}};let m;try{let v=Tt(_optionalChain([a, 'optionalAccess', _26 => _26.expectedStreamVersion])),P=o.map((I,f)=>({...I,metadata:{streamName:e,eventId:_uuid.v4.call(void 0, ),streamPosition:BigInt(f),...I.metadata}}));m=await St(l,e,n,P,{expectedStreamVersion:v}),_optionalChain([a, 'optionalAccess', _27 => _27.preCommitHook])&&await a.preCommitHook(P,{transaction:r})}catch(v){if(!gt(v))throw v;m={success:!1,last_global_position:null,next_stream_position:null,transaction_id:null}}let{success:p,next_stream_position:c,last_global_position:E,transaction_id:d}=m;return{success:p,result:p&&c&&E&&d?{success:!0,nextStreamPosition:BigInt(c),lastGlobalPosition:BigInt(E),transactionId:d}:{success:!1}}}),Tt=t=>t===void 0||t===N||t==U||t==F?null:t,gt=t=>t instanceof Error&&"code"in t&&t.code==="23505",St=(t,e,n,o,a)=>_dumbo.single.call(void 0, t.command(_dumbo.sql.call(void 0, `SELECT * FROM emt_append_event(
+  `
+);
+var appendToStream = (pool, streamName, streamType, events, options) => pool.withTransaction(async (transaction) => {
+  const { execute } = transaction;
+  if (events.length === 0)
+    return { success: false, result: { success: false } };
+  let appendResult;
+  try {
+    const expectedStreamVersion = toExpectedVersion(
+      _optionalChain([options, 'optionalAccess', _26 => _26.expectedStreamVersion])
+    );
+    const eventsToAppend = events.map((e, i) => ({
+      ...e,
+      metadata: {
+        streamName,
+        eventId: _uuid.v4.call(void 0, ),
+        streamPosition: BigInt(i),
+        ...e.metadata
+      }
+    }));
+    appendResult = await appendEventsRaw(
+      execute,
+      streamName,
+      streamType,
+      eventsToAppend,
+      {
+        expectedStreamVersion
+      }
+    );
+    if (_optionalChain([options, 'optionalAccess', _27 => _27.preCommitHook]))
+      await options.preCommitHook(eventsToAppend, { transaction });
+  } catch (error) {
+    if (!isOptimisticConcurrencyError(error)) throw error;
+    appendResult = {
+      success: false,
+      last_global_position: null,
+      next_stream_position: null,
+      transaction_id: null
+    };
+  }
+  const {
+    success,
+    next_stream_position,
+    last_global_position,
+    transaction_id
+  } = appendResult;
+  return {
+    success,
+    result: success && next_stream_position && last_global_position && transaction_id ? {
+      success: true,
+      nextStreamPosition: BigInt(next_stream_position),
+      lastGlobalPosition: BigInt(last_global_position),
+      transactionId: transaction_id
+    } : { success: false }
+  };
+});
+var toExpectedVersion = (expected) => {
+  if (expected === void 0) return null;
+  if (expected === NO_CONCURRENCY_CHECK) return null;
+  if (expected == STREAM_DOES_NOT_EXIST) return null;
+  if (expected == STREAM_EXISTS) return null;
+  return expected;
+};
+var isOptimisticConcurrencyError = (error) => error instanceof Error && "code" in error && error.code === "23505";
+var appendEventsRaw = (execute, streamId, streamType, events, options) => _dumbo.single.call(void 0, 
+  execute.command(
+    _dumbo.sql.call(void 0, 
+      `SELECT * FROM emt_append_event(
                   ARRAY[%s]::text[],
                   ARRAY[%s]::jsonb[],
                   ARRAY[%s]::jsonb[],
@@ -95,22 +966,42 @@ Actual:${h.stringify(e)}`)}function se(t,e,n){if(t===e)throw new y(_nullishCoale
                   %L::text,
                   %s::bigint,
                   %L::text
-              )`,o.map(r=>_dumbo.sql.call(void 0, "%L",r.metadata.eventId)).join(","),o.map(r=>_dumbo.sql.call(void 0, "%L",h.stringify(r.data))).join(","),o.map(r=>_dumbo.sql.call(void 0, "%L",h.stringify(_nullishCoalesce(r.metadata, () => ({}))))).join(","),o.map(()=>"'1'").join(","),o.map(r=>_dumbo.sql.call(void 0, "%L",r.type)).join(","),e,n,_nullishCoalesce(_optionalChain([a, 'optionalAccess', _28 => _28.expectedStreamVersion]), () => ("NULL")),_nullishCoalesce(_optionalChain([a, 'optionalAccess', _29 => _29.partition]), () => (O)))));var ue=_dumbo.rawSql.call(void 0, `CREATE TABLE IF NOT EXISTS ${s.name}(
+              )`,
+      events.map((e) => _dumbo.sql.call(void 0, "%L", e.metadata.eventId)).join(","),
+      events.map((e) => _dumbo.sql.call(void 0, "%L", JSONParser.stringify(e.data))).join(","),
+      events.map((e) => _dumbo.sql.call(void 0, "%L", JSONParser.stringify(_nullishCoalesce(e.metadata, () => ( {}))))).join(","),
+      events.map(() => `'1'`).join(","),
+      events.map((e) => _dumbo.sql.call(void 0, "%L", e.type)).join(","),
+      streamId,
+      streamType,
+      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _28 => _28.expectedStreamVersion]), () => ( "NULL")),
+      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _29 => _29.partition]), () => ( defaultTag))
+    )
+  )
+);
+
+// src/eventStore/schema/tables.ts
+
+var streamsTableSQL = _dumbo.rawSql.call(void 0, 
+  `CREATE TABLE IF NOT EXISTS ${streamsTable.name}(
       stream_id         TEXT                      NOT NULL,
       stream_position   BIGINT                    NOT NULL,
-      partition         TEXT                      NOT NULL DEFAULT '${u}__${u}',
+      partition         TEXT                      NOT NULL DEFAULT '${globalTag}__${globalTag}',
       stream_type       TEXT                      NOT NULL,
       stream_metadata   JSONB                     NOT NULL,
       is_archived       BOOLEAN                   NOT NULL DEFAULT FALSE,
       PRIMARY KEY (stream_id, stream_position, partition, is_archived),
       UNIQUE (stream_id, partition, is_archived)
-  ) PARTITION BY LIST (partition);`),_e= exports.eventsTableSQL =_dumbo.rawSql.call(void 0, `
+  ) PARTITION BY LIST (partition);`
+);
+var eventsTableSQL = _dumbo.rawSql.call(void 0, 
+  `
   CREATE SEQUENCE IF NOT EXISTS emt_global_event_position;
 
-  CREATE TABLE IF NOT EXISTS ${i.name}(
+  CREATE TABLE IF NOT EXISTS ${eventsTable.name}(
       stream_id              TEXT                      NOT NULL,
       stream_position        BIGINT                    NOT NULL,
-      partition              TEXT                      NOT NULL DEFAULT '${u}',
+      partition              TEXT                      NOT NULL DEFAULT '${globalTag}',
       event_data             JSONB                     NOT NULL,
       event_metadata         JSONB                     NOT NULL,
       event_schema_version   TEXT                      NOT NULL,
@@ -121,7 +1012,10 @@ Actual:${h.stringify(e)}`)}function se(t,e,n){if(t===e)throw new y(_nullishCoale
       transaction_id         XID8                      NOT NULL,
       created                TIMESTAMPTZ               NOT NULL DEFAULT now(),
       PRIMARY KEY (stream_id, stream_position, partition, is_archived)
-  ) PARTITION BY LIST (partition);`),Te= exports.subscriptionsTableSQL =_dumbo.rawSql.call(void 0, `
+  ) PARTITION BY LIST (partition);`
+);
+var subscriptionsTableSQL = _dumbo.rawSql.call(void 0, 
+  `
   CREATE TABLE IF NOT EXISTS emt_subscriptions(
       subscription_id                 TEXT                   NOT NULL PRIMARY KEY,
       version                         INT                    NOT NULL DEFAULT 1,
@@ -130,11 +1024,17 @@ Actual:${h.stringify(e)}`)}function se(t,e,n){if(t===e)throw new y(_nullishCoale
       last_processed_position         BIGINT                 NOT NULL,
       last_processed_transaction_id   BIGINT                 NOT NULL
   );
-`),ge= exports.sanitizeNameSQL =_dumbo.rawSql.call(void 0, `CREATE OR REPLACE FUNCTION emt_sanitize_name(input_name TEXT) RETURNS TEXT AS $$
+`
+);
+var sanitizeNameSQL = _dumbo.rawSql.call(void 0, 
+  `CREATE OR REPLACE FUNCTION emt_sanitize_name(input_name TEXT) RETURNS TEXT AS $$
     BEGIN
         RETURN REGEXP_REPLACE(input_name, '[^a-zA-Z0-9_]', '_', 'g');
     END;
-    $$ LANGUAGE plpgsql;`),Se= exports.addTablePartitions =_dumbo.rawSql.call(void 0, `
+    $$ LANGUAGE plpgsql;`
+);
+var addTablePartitions = _dumbo.rawSql.call(void 0, 
+  `
   CREATE OR REPLACE FUNCTION emt_add_table_partition(tableName TEXT, partition_name TEXT) RETURNS void AS $$
   DECLARE
     v_main_partiton_name     TEXT;
@@ -171,193 +1071,432 @@ Actual:${h.stringify(e)}`)}function se(t,e,n){if(t===e)throw new y(_nullishCoale
           v_archived_partiton_name, v_main_partiton_name
       );
   END;
-  $$ LANGUAGE plpgsql;`),fe= exports.addEventsPartitions =_dumbo.rawSql.call(void 0, `
+  $$ LANGUAGE plpgsql;`
+);
+var addEventsPartitions = _dumbo.rawSql.call(void 0, 
+  `
   CREATE OR REPLACE FUNCTION emt_add_partition(partition_name TEXT) RETURNS void AS $$
   BEGIN                
-      PERFORM emt_add_table_partition('${i.name}', partition_name);
-      PERFORM emt_add_table_partition('${s.name}', partition_name);
+      PERFORM emt_add_table_partition('${eventsTable.name}', partition_name);
+      PERFORM emt_add_table_partition('${streamsTable.name}', partition_name);
   END;
-  $$ LANGUAGE plpgsql;`),ye= exports.addModuleSQL =_dumbo.rawSql.call(void 0, `
+  $$ LANGUAGE plpgsql;`
+);
+var addModuleSQL = _dumbo.rawSql.call(void 0, 
+  `
       CREATE OR REPLACE FUNCTION add_module(new_module TEXT) RETURNS void AS $$
       BEGIN
-          -- For ${i.name} table
+          -- For ${eventsTable.name} table
           EXECUTE format('
               CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
               FOR VALUES IN (emt_sanitize_name(%L || ''__'' || %L)) PARTITION BY LIST (is_archived);',
-              emt_sanitize_name('${i.name}_' || new_module || '__' || '${u}'), '${i.name}', new_module, '${u}'
+              emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || '${globalTag}'), '${eventsTable.name}', new_module, '${globalTag}'
           );
   
           EXECUTE format('
               CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
               FOR VALUES IN (FALSE);',
-              emt_sanitize_name('${i.name}_' || new_module || '__' || '${u}' || '_active'), emt_sanitize_name('${i.name}_' || new_module || '__' || '${u}')
+              emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || '${globalTag}' || '_active'), emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || '${globalTag}')
           );
   
           EXECUTE format('
               CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
               FOR VALUES IN (TRUE);',
-              emt_sanitize_name('${i.name}_' || new_module || '__' || '${u}' || '_archived'), emt_sanitize_name('${i.name}_' || new_module || '__' || '${u}')
+              emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || '${globalTag}' || '_archived'), emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || '${globalTag}')
           );
   
-          -- For ${s.name} table
+          -- For ${streamsTable.name} table
           EXECUTE format('
               CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
               FOR VALUES IN (emt_sanitize_name(%L || ''__'' || %L)) PARTITION BY LIST (is_archived);',
-              emt_sanitize_name('${s.name}_' || new_module || '__' || '${u}'), '${s.name}', new_module, '${u}'
+              emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || '${globalTag}'), '${streamsTable.name}', new_module, '${globalTag}'
           );
   
           EXECUTE format('
               CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
               FOR VALUES IN (FALSE);',
-              emt_sanitize_name('${s.name}_' || new_module || '__' || '${u}' || '_active'), emt_sanitize_name('${s.name}_' || new_module || '__' || '${u}')
+              emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || '${globalTag}' || '_active'), emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || '${globalTag}')
           );
   
           EXECUTE format('
               CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
               FOR VALUES IN (TRUE);',
-              emt_sanitize_name('${s.name}_' || new_module || '__' || '${u}' || '_archived'), emt_sanitize_name('${s.name}_' || new_module || '__' || '${u}')
+              emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || '${globalTag}' || '_archived'), emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || '${globalTag}')
           );
       END;
       $$ LANGUAGE plpgsql;
-    `),he= exports.addTenantSQL =_dumbo.rawSql.call(void 0, `
+    `
+);
+var addTenantSQL = _dumbo.rawSql.call(void 0, 
+  `
     CREATE OR REPLACE FUNCTION add_tenant(new_module TEXT, new_tenant TEXT) RETURNS void AS $$
     BEGIN
-        -- For ${i.name} table
+        -- For ${eventsTable.name} table
         EXECUTE format('
             CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
             FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-            emt_sanitize_name('${i.name}_' || new_module || '__' || new_tenant), '${i.name}', new_module, new_tenant
+            emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || new_tenant), '${eventsTable.name}', new_module, new_tenant
         );
   
         EXECUTE format('
             CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
             FOR VALUES IN (FALSE);',
-            emt_sanitize_name('${i.name}_' || new_module || '__' || new_tenant || '_active'), emt_sanitize_name('${i.name}_' || new_module || '__' || new_tenant)
+            emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || new_tenant || '_active'), emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || new_tenant)
         );
   
         EXECUTE format('
             CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
             FOR VALUES IN (TRUE);',
-            emt_sanitize_name('${i.name}_' || new_module || '__' || new_tenant || '_archived'), emt_sanitize_name('${i.name}_' || new_module || '__' || new_tenant)
+            emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || new_tenant || '_archived'), emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || new_tenant)
         );
   
-        -- For ${s.name} table
+        -- For ${streamsTable.name} table
         EXECUTE format('
             CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
             FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-            emt_sanitize_name('${s.name}_' || new_module || '__' || new_tenant), '${s.name}', new_module, new_tenant
+            emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || new_tenant), '${streamsTable.name}', new_module, new_tenant
         );
   
         EXECUTE format('
             CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
             FOR VALUES IN (FALSE);',
-            emt_sanitize_name('${s.name}_' || new_module || '__' || new_tenant || '_active'), emt_sanitize_name('${s.name}_' || new_module || '__' || new_tenant)
+            emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || new_tenant || '_active'), emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || new_tenant)
         );
   
         EXECUTE format('
             CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
             FOR VALUES IN (TRUE);',
-            emt_sanitize_name('${s.name}_' || new_module || '__' || new_tenant || '_archived'), emt_sanitize_name('${s.name}_' || new_module || '__' || new_tenant)
+            emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || new_tenant || '_archived'), emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || new_tenant)
         );
     END;
     $$ LANGUAGE plpgsql;
-  `),Pe= exports.addModuleForAllTenantsSQL =_dumbo.rawSql.call(void 0, `
+  `
+);
+var addModuleForAllTenantsSQL = _dumbo.rawSql.call(void 0, 
+  `
     CREATE OR REPLACE FUNCTION add_module_for_all_tenants(new_module TEXT) RETURNS void AS $$
     DECLARE
         tenant_record RECORD;
     BEGIN
         PERFORM add_module(new_module);
   
-        FOR tenant_record IN SELECT DISTINCT tenant FROM ${i.name}
+        FOR tenant_record IN SELECT DISTINCT tenant FROM ${eventsTable.name}
         LOOP
-            -- For ${i.name} table
+            -- For ${eventsTable.name} table
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
                 FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-                emt_sanitize_name('${i.name}_' || new_module || '__' || tenant_record.tenant), '${i.name}', new_module, tenant_record.tenant
+                emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || tenant_record.tenant), '${eventsTable.name}', new_module, tenant_record.tenant
             );
   
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
                 FOR VALUES IN (FALSE);',
-                emt_sanitize_name('${i.name}_' || new_module || '__' || tenant_record.tenant || '_active'), emt_sanitize_name('${i.name}_' || new_module || '__' || tenant_record.tenant)
+                emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || tenant_record.tenant || '_active'), emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || tenant_record.tenant)
             );
   
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
                 FOR VALUES IN (TRUE);',
-                emt_sanitize_name('${i.name}_' || new_module || '__' || tenant_record.tenant || '_archived'), emt_sanitize_name('${i.name}_' || new_module || '__' || tenant_record.tenant)
+                emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || tenant_record.tenant || '_archived'), emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || tenant_record.tenant)
             );
   
-            -- For ${s.name} table
+            -- For ${streamsTable.name} table
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
                 FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-                emt_sanitize_name('${s.name}_' || new_module || '__' || tenant_record.tenant), '${s.name}', new_module, tenant_record.tenant
+                emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || tenant_record.tenant), '${streamsTable.name}', new_module, tenant_record.tenant
             );
   
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
                 FOR VALUES IN (FALSE);',
-                emt_sanitize_name('${s.name}_' || new_module || '__' || tenant_record.tenant || '_active'), emt_sanitize_name('${s.name}_' || new_module || '__' || tenant_record.tenant)
+                emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || tenant_record.tenant || '_active'), emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || tenant_record.tenant)
             );
   
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
                 FOR VALUES IN (TRUE);',
-                emt_sanitize_name('${s.name}_' || new_module || '__' || tenant_record.tenant || '_archived'), emt_sanitize_name('${s.name}_' || new_module || '__' || tenant_record.tenant)
+                emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || tenant_record.tenant || '_archived'), emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || tenant_record.tenant)
             );
         END LOOP;
     END;
     $$ LANGUAGE plpgsql;
-  `),Ie= exports.addTenantForAllModulesSQL =_dumbo.rawSql.call(void 0, `
+  `
+);
+var addTenantForAllModulesSQL = _dumbo.rawSql.call(void 0, 
+  `
     CREATE OR REPLACE FUNCTION add_tenant_for_all_modules(new_tenant TEXT) RETURNS void AS $$
     DECLARE
         module_record RECORD;
     BEGIN
-        FOR module_record IN SELECT DISTINCT partitionname FROM pg_partman.part_config WHERE parent_table = '${i.name}'
+        FOR module_record IN SELECT DISTINCT partitionname FROM pg_partman.part_config WHERE parent_table = '${eventsTable.name}'
         LOOP
-            -- For ${i.name} table
+            -- For ${eventsTable.name} table
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
                 FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-                emt_sanitize_name('${i.name}_' || module_record.partitionname || '__' || new_tenant), '${i.name}', module_record.partitionname, new_tenant
+                emt_sanitize_name('${eventsTable.name}_' || module_record.partitionname || '__' || new_tenant), '${eventsTable.name}', module_record.partitionname, new_tenant
             );
   
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
                 FOR VALUES IN (FALSE);',
-                emt_sanitize_name('${i.name}_' || module_record.partitionname || '__' || new_tenant || '_active'), emt_sanitize_name('${i.name}_' || module_record.partitionname || '__' || new_tenant)
+                emt_sanitize_name('${eventsTable.name}_' || module_record.partitionname || '__' || new_tenant || '_active'), emt_sanitize_name('${eventsTable.name}_' || module_record.partitionname || '__' || new_tenant)
             );
   
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
                 FOR VALUES IN (TRUE);',
-                emt_sanitize_name('${i.name}_' || module_record.partitionname || '__' || new_tenant || '_archived'), emt_sanitize_name('${i.name}_' || module_record.partitionname || '__' || new_tenant)
+                emt_sanitize_name('${eventsTable.name}_' || module_record.partitionname || '__' || new_tenant || '_archived'), emt_sanitize_name('${eventsTable.name}_' || module_record.partitionname || '__' || new_tenant)
             );
   
-            -- For ${s.name} table
+            -- For ${streamsTable.name} table
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
                 FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-                emt_sanitize_name('${s.name}_' || module_record.partitionname || '__' || new_tenant), '${s.name}', module_record.partitionname, new_tenant
+                emt_sanitize_name('${streamsTable.name}_' || module_record.partitionname || '__' || new_tenant), '${streamsTable.name}', module_record.partitionname, new_tenant
             );
   
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
                 FOR VALUES IN (FALSE);',
-                emt_sanitize_name('${s.name}_' || module_record.partitionname || '__' || new_tenant || '_active'), emt_sanitize_name('${s.name}_' || module_record.partitionname || '__' || new_tenant)
+                emt_sanitize_name('${streamsTable.name}_' || module_record.partitionname || '__' || new_tenant || '_active'), emt_sanitize_name('${streamsTable.name}_' || module_record.partitionname || '__' || new_tenant)
             );
   
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
                 FOR VALUES IN (TRUE);',
-                emt_sanitize_name('${s.name}_' || module_record.partitionname || '__' || new_tenant || '_archived'), emt_sanitize_name('${s.name}_' || module_record.partitionname || '__' || new_tenant)
+                emt_sanitize_name('${streamsTable.name}_' || module_record.partitionname || '__' || new_tenant || '_archived'), emt_sanitize_name('${streamsTable.name}_' || module_record.partitionname || '__' || new_tenant)
             );
         END LOOP;
     END;
     $$ LANGUAGE plpgsql;
-  `),Ne= exports.addDefaultPartition =_dumbo.rawSql.call(void 0, `SELECT emt_add_partition('${O}');`);var Oe=async(t,e,n)=>{let o=n&&"from"in n?`AND stream_position >= ${n.from}`:"",a=Number(n&&"to"in n?n.to:n&&"maxCount"in n&&n.maxCount?n.from+n.maxCount:NaN),r=isNaN(a)?"":`AND stream_position <= ${a}`,l=await _dumbo.mapRows.call(void 0, t.query(_dumbo.sql.call(void 0, `SELECT stream_id, stream_position, global_position, event_data, event_metadata, event_schema_version, event_type, event_id
-           FROM ${i.name}
-           WHERE stream_id = %L AND partition = %L AND is_archived = FALSE ${o} ${r}`,e,_nullishCoalesce(_optionalChain([n, 'optionalAccess', _30 => _30.partition]), () => (O)))),m=>{let p=J(m.event_type,m.event_data,m.event_metadata);return{...p,metadata:{...p.metadata,eventId:m.event_id,streamName:e,streamPosition:BigInt(m.stream_position),globalPosition:BigInt(m.global_position)}}});return l.length>0?{currentStreamVersion:l[l.length-1].metadata.streamPosition,events:l,streamExists:!0}:{currentStreamVersion:B,events:[],streamExists:!1}};var C=[ue,_e,Te,ge,Se,fe,ye,he,Pe,Ie,pe,Ne],X= exports.createEventStoreSchema =async t=>{await t.withTransaction(({execute:e})=>e.batchCommand(C))};var Pt={projections:[],schema:{autoMigration:"CreateOrUpdate"}},B= exports.PostgreSQLEventStoreDefaultStreamVersion =0n,It= exports.getPostgreSQLEventStore =(t,e=Pt)=>{let n={connectionString:t,...e.connectionOptions?e.connectionOptions:{}},o="dumbo"in n?n.dumbo:_dumbo.dumbo.call(void 0, n),a,r=_optionalChain([e, 'access', _31 => _31.schema, 'optionalAccess', _32 => _32.autoMigration])===void 0||_optionalChain([e, 'access', _33 => _33.schema, 'optionalAccess', _34 => _34.autoMigration])!=="None",l=()=>r?(a||(a=X(o)),a):Promise.resolve(),m=(_nullishCoalesce(e.projections, () => ([]))).filter(({type:c})=>c==="inline").map(({projection:c})=>c),p=m.length>0?(c,{transaction:E})=>D({projections:m,connection:{connectionString:t,transaction:E},events:c}):void 0;return{schema:{sql:()=>C.join(""),print:()=>console.log(C.join("")),migrate:async()=>{await(a=X(o))}},async aggregateStream(c,E){let{evolve:d,initialState:v,read:P}=E,I=_optionalChain([P, 'optionalAccess', _35 => _35.expectedStreamVersion]),f=v(),b=await this.readStream(c,E.read),V=b.currentStreamVersion;K(V,I,B);for(let G of b.events)G&&(f=d(f,G));return{currentStreamVersion:V,state:f,streamExists:b.streamExists}},readStream:async(c,E)=>(await l(),Oe(o.execute,c,E)),appendToStream:async(c,E,d)=>{await l();let[v,...P]=c.split("-"),I=v&&P.length>0?v:"emt:unknown",f=await ve(o,c,I,E,{...d,preCommitHook:p});if(!f.success)throw new $(-1n,_nullishCoalesce(_optionalChain([d, 'optionalAccess', _36 => _36.expectedStreamVersion]), () => (N)));return{nextExpectedStreamVersion:f.nextStreamPosition,createdNewStream:f.nextStreamPosition>=BigInt(E.length)}},close:()=>o.close(),async withSession(c){return await o.withConnection(async E=>{let d={...e,connectionOptions:{connection:E}},v=It(t,d);return c({eventStore:v,close:()=>Promise.resolve()})})}}};exports.PostgreSQLEventStoreDefaultStreamVersion = B; exports.PostgreSQLProjectionSpec = wn; exports.addDefaultPartition = Ne; exports.addEventsPartitions = fe; exports.addModuleForAllTenantsSQL = Pe; exports.addModuleSQL = ye; exports.addTablePartitions = Se; exports.addTenantForAllModulesSQL = Ie; exports.addTenantSQL = he; exports.appendEventsSQL = pe; exports.appendToStream = ve; exports.assertSQLQueryResultMatches = Et; exports.createEventStoreSchema = X; exports.defaultPostgreSQLOptions = Pt; exports.defaultTag = O; exports.documentDoesNotExist = de; exports.documentExists = at; exports.documentMatchingExists = me; exports.documentsAreTheSame = rt; exports.documentsMatchingHaveCount = it; exports.emmettPrefix = x; exports.eventInStream = dt; exports.eventsInStream = lt; exports.eventsTable = i; exports.eventsTableSQL = _e; exports.expectPongoDocuments = gn; exports.expectSQL = bn; exports.getPostgreSQLEventStore = It; exports.globalNames = Xn; exports.globalTag = u; exports.handleProjections = D; exports.newEventsInStream = Cn; exports.pongoMultiStreamProjection = mt; exports.pongoProjection = ct; exports.pongoSingleStreamProjection = Pn; exports.postgreSQLProjection = Q; exports.postgreSQLRawBatchSQLProjection = pt; exports.postgreSQLRawSQLProjection = $n; exports.readStream = Oe; exports.sanitizeNameSQL = ge; exports.schemaSQL = C; exports.streamsTable = s; exports.streamsTableSQL = ue; exports.subscriptionsTableSQL = Te;
+  `
+);
+var addDefaultPartition = _dumbo.rawSql.call(void 0, 
+  `SELECT emt_add_partition('${defaultTag}');`
+);
+
+// src/eventStore/schema/readStream.ts
+
+var readStream = async (execute, streamId, options) => {
+  const fromCondition = options && "from" in options ? `AND stream_position >= ${options.from}` : "";
+  const to = Number(
+    options && "to" in options ? options.to : options && "maxCount" in options && options.maxCount ? options.from + options.maxCount : NaN
+  );
+  const toCondition = !isNaN(to) ? `AND stream_position <= ${to}` : "";
+  const events = await _dumbo.mapRows.call(void 0, 
+    execute.query(
+      _dumbo.sql.call(void 0, 
+        `SELECT stream_id, stream_position, global_position, event_data, event_metadata, event_schema_version, event_type, event_id
+           FROM ${eventsTable.name}
+           WHERE stream_id = %L AND partition = %L AND is_archived = FALSE ${fromCondition} ${toCondition}`,
+        streamId,
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _30 => _30.partition]), () => ( defaultTag))
+      )
+    ),
+    (row) => {
+      const rawEvent = event(
+        row.event_type,
+        row.event_data,
+        row.event_metadata
+      );
+      return {
+        ...rawEvent,
+        metadata: {
+          ...rawEvent.metadata,
+          eventId: row.event_id,
+          streamName: streamId,
+          streamPosition: BigInt(row.stream_position),
+          globalPosition: BigInt(row.global_position)
+        }
+      };
+    }
+  );
+  return events.length > 0 ? {
+    currentStreamVersion: events[events.length - 1].metadata.streamPosition,
+    events,
+    streamExists: true
+  } : {
+    currentStreamVersion: PostgreSQLEventStoreDefaultStreamVersion,
+    events: [],
+    streamExists: false
+  };
+};
+
+// src/eventStore/schema/index.ts
+var schemaSQL = [
+  streamsTableSQL,
+  eventsTableSQL,
+  subscriptionsTableSQL,
+  sanitizeNameSQL,
+  addTablePartitions,
+  addEventsPartitions,
+  addModuleSQL,
+  addTenantSQL,
+  addModuleForAllTenantsSQL,
+  addTenantForAllModulesSQL,
+  appendEventsSQL,
+  addDefaultPartition
+];
+var createEventStoreSchema = async (pool) => {
+  await pool.withTransaction(({ execute }) => execute.batchCommand(schemaSQL));
+};
+
+// src/eventStore/postgreSQLEventStore.ts
+var defaultPostgreSQLOptions = {
+  projections: [],
+  schema: { autoMigration: "CreateOrUpdate" }
+};
+var PostgreSQLEventStoreDefaultStreamVersion = 0n;
+var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOptions) => {
+  const poolOptions = {
+    connectionString,
+    ...options.connectionOptions ? options.connectionOptions : {}
+  };
+  const pool = "dumbo" in poolOptions ? poolOptions.dumbo : _dumbo.dumbo.call(void 0, poolOptions);
+  let migrateSchema;
+  const autoGenerateSchema = _optionalChain([options, 'access', _31 => _31.schema, 'optionalAccess', _32 => _32.autoMigration]) === void 0 || _optionalChain([options, 'access', _33 => _33.schema, 'optionalAccess', _34 => _34.autoMigration]) !== "None";
+  const ensureSchemaExists = () => {
+    if (!autoGenerateSchema) return Promise.resolve();
+    if (!migrateSchema) {
+      migrateSchema = createEventStoreSchema(pool);
+    }
+    return migrateSchema;
+  };
+  const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
+  const preCommitHook = inlineProjections.length > 0 ? (events, { transaction }) => handleProjections({
+    projections: inlineProjections,
+    connection: {
+      connectionString,
+      transaction
+    },
+    events
+  }) : void 0;
+  return {
+    schema: {
+      sql: () => schemaSQL.join(""),
+      print: () => console.log(schemaSQL.join("")),
+      migrate: async () => {
+        await (migrateSchema = createEventStoreSchema(pool));
+      }
+    },
+    async aggregateStream(streamName, options2) {
+      const { evolve, initialState, read } = options2;
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _35 => _35.expectedStreamVersion]);
+      let state = initialState();
+      const result = await this.readStream(streamName, options2.read);
+      const currentStreamVersion = result.currentStreamVersion;
+      assertExpectedVersionMatchesCurrent(
+        currentStreamVersion,
+        expectedStreamVersion,
+        PostgreSQLEventStoreDefaultStreamVersion
+      );
+      for (const event2 of result.events) {
+        if (!event2) continue;
+        state = evolve(state, event2);
+      }
+      return {
+        currentStreamVersion,
+        state,
+        streamExists: result.streamExists
+      };
+    },
+    readStream: async (streamName, options2) => {
+      await ensureSchemaExists();
+      return readStream(pool.execute, streamName, options2);
+    },
+    appendToStream: async (streamName, events, options2) => {
+      await ensureSchemaExists();
+      const [firstPart, ...rest] = streamName.split("-");
+      const streamType = firstPart && rest.length > 0 ? firstPart : "emt:unknown";
+      const appendResult = await appendToStream(
+        pool,
+        streamName,
+        streamType,
+        events,
+        {
+          ...options2,
+          preCommitHook
+        }
+      );
+      if (!appendResult.success)
+        throw new ExpectedVersionConflictError(
+          -1n,
+          //TODO: Return actual version in case of error
+          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _36 => _36.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+        );
+      return {
+        nextExpectedStreamVersion: appendResult.nextStreamPosition,
+        createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
+      };
+    },
+    close: () => pool.close(),
+    async withSession(callback) {
+      return await pool.withConnection(async (connection) => {
+        const storeOptions = {
+          ...options,
+          connectionOptions: {
+            connection
+          }
+        };
+        const eventStore = getPostgreSQLEventStore(
+          connectionString,
+          storeOptions
+        );
+        return callback({
+          eventStore,
+          close: () => Promise.resolve()
+        });
+      });
+    }
+  };
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.PostgreSQLEventStoreDefaultStreamVersion = PostgreSQLEventStoreDefaultStreamVersion; exports.PostgreSQLProjectionSpec = PostgreSQLProjectionSpec; exports.addDefaultPartition = addDefaultPartition; exports.addEventsPartitions = addEventsPartitions; exports.addModuleForAllTenantsSQL = addModuleForAllTenantsSQL; exports.addModuleSQL = addModuleSQL; exports.addTablePartitions = addTablePartitions; exports.addTenantForAllModulesSQL = addTenantForAllModulesSQL; exports.addTenantSQL = addTenantSQL; exports.appendEventsSQL = appendEventsSQL; exports.appendToStream = appendToStream; exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches; exports.createEventStoreSchema = createEventStoreSchema; exports.defaultPostgreSQLOptions = defaultPostgreSQLOptions; exports.defaultTag = defaultTag; exports.documentDoesNotExist = documentDoesNotExist; exports.documentExists = documentExists; exports.documentMatchingExists = documentMatchingExists; exports.documentsAreTheSame = documentsAreTheSame; exports.documentsMatchingHaveCount = documentsMatchingHaveCount; exports.emmettPrefix = emmettPrefix; exports.eventInStream = eventInStream; exports.eventsInStream = eventsInStream; exports.eventsTable = eventsTable; exports.eventsTableSQL = eventsTableSQL; exports.expectPongoDocuments = expectPongoDocuments; exports.expectSQL = expectSQL; exports.getPostgreSQLEventStore = getPostgreSQLEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.newEventsInStream = newEventsInStream; exports.pongoMultiStreamProjection = pongoMultiStreamProjection; exports.pongoProjection = pongoProjection; exports.pongoSingleStreamProjection = pongoSingleStreamProjection; exports.postgreSQLProjection = postgreSQLProjection; exports.postgreSQLRawBatchSQLProjection = postgreSQLRawBatchSQLProjection; exports.postgreSQLRawSQLProjection = postgreSQLRawSQLProjection; exports.readStream = readStream; exports.sanitizeNameSQL = sanitizeNameSQL; exports.schemaSQL = schemaSQL; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.subscriptionsTableSQL = subscriptionsTableSQL;
 //# sourceMappingURL=index.cjs.map