@ocoda/event-sourcing-mariadb 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# @ocoda/event-sourcing-mariadb
+
+## 1.0.0
+
+### Major Changes
+
+- This marks the first stable release of the library, which consists of the following changes:
+
+  - all database-specific libraries have been migrated to their own libraries to reduce the bundle size
+  - the `SnapshotHandler` was renamed to `SnapshotRepository`
+  - the `SnapshotRepository` was provided with additional methods for retrieving snapshots in bulk
+  - the database drivers were optimized (e.g. by only fetching the needed fields)
+  - the DynamoDB snapshot-store serialization was fixed
+
+### Patch Changes
+
+- Updated dependencies
+  - @ocoda/event-sourcing@1.0.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Ocoda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,67 @@
+import { IEventPayload, IEvent, EventStore, IEventPool, IEventCollection, EventStream, IEventFilter, EventEnvelope, EventStoreConfig, AggregateRoot, ISnapshot, SnapshotStore, ISnapshotPool, ISnapshotCollection, SnapshotStream, ISnapshotFilter, SnapshotEnvelope, ILatestSnapshotFilter, SnapshotStoreConfig } from '@ocoda/event-sourcing';
+import { Type } from '@nestjs/common';
+import { PoolConfig } from 'mariadb';
+
+type MariaDBEventEntity = {
+    stream_id: string;
+    version: number;
+    event: string;
+    payload: IEventPayload<IEvent>;
+    event_id: string;
+    aggregate_id: string;
+    occurred_on: Date;
+    correlation_id: string | null;
+    causation_id: string | null;
+};
+
+declare class MariaDBEventStore extends EventStore<MariaDBEventStoreConfig> {
+    private pool;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    ensureCollection(pool?: IEventPool): Promise<IEventCollection>;
+    getEvents({ streamId }: EventStream, filter?: IEventFilter): AsyncGenerator<IEvent[]>;
+    getEvent({ streamId }: EventStream, version: number, pool?: IEventPool): Promise<IEvent>;
+    appendEvents(stream: EventStream, aggregateVersion: number, events: IEvent[], pool?: IEventPool): Promise<EventEnvelope[]>;
+    getEnvelopes({ streamId }: EventStream, filter?: IEventFilter): AsyncGenerator<EventEnvelope[]>;
+    getEnvelope({ streamId }: EventStream, version: number, pool?: IEventPool): Promise<EventEnvelope>;
+}
+
+interface MariaDBEventStoreConfig extends EventStoreConfig, PoolConfig {
+    driver: Type<MariaDBEventStore>;
+}
+
+type MariaDBSnapshotEntity<A extends AggregateRoot> = {
+    stream_id: string;
+    version: number;
+    payload: ISnapshot<A>;
+    snapshot_id: string;
+    aggregate_id: string;
+    registered_on: Date;
+    aggregate_name: string;
+    latest?: string;
+};
+
+declare class MariaDBSnapshotStore extends SnapshotStore<MariaDBSnapshotStoreConfig> {
+    private pool;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    ensureCollection(pool?: ISnapshotPool): Promise<ISnapshotCollection>;
+    stop(): Promise<void>;
+    getSnapshots<A extends AggregateRoot>({ streamId }: SnapshotStream, filter?: ISnapshotFilter): AsyncGenerator<ISnapshot<A>[]>;
+    getSnapshot<A extends AggregateRoot>({ streamId }: SnapshotStream, version: number, pool?: ISnapshotPool): Promise<ISnapshot<A>>;
+    appendSnapshot<A extends AggregateRoot>(stream: SnapshotStream, aggregateVersion: number, snapshot: ISnapshot<A>, pool?: ISnapshotPool): Promise<SnapshotEnvelope<A>>;
+    getLastSnapshot<A extends AggregateRoot>(stream: SnapshotStream, pool?: ISnapshotPool): Promise<ISnapshot<A>>;
+    getManyLastSnapshots<A extends AggregateRoot>(streams: SnapshotStream[], pool?: ISnapshotPool): Promise<Map<SnapshotStream, ISnapshot<A>>>;
+    getLastEnvelope<A extends AggregateRoot>(stream: SnapshotStream, pool?: ISnapshotPool): Promise<SnapshotEnvelope<A>>;
+    getEnvelopes<A extends AggregateRoot>({ streamId }: SnapshotStream, filter?: ISnapshotFilter): AsyncGenerator<SnapshotEnvelope<A>[]>;
+    getEnvelope<A extends AggregateRoot>({ streamId }: SnapshotStream, version: number, pool?: ISnapshotPool): Promise<SnapshotEnvelope<A>>;
+    getLastAggregateEnvelopes<A extends AggregateRoot>(aggregateName: string, filter?: ILatestSnapshotFilter): AsyncGenerator<SnapshotEnvelope<A>[]>;
+    getManyLastSnapshotEnvelopes<A extends AggregateRoot>(streams: SnapshotStream[], pool?: ISnapshotPool): Promise<Map<SnapshotStream, SnapshotEnvelope<A>>>;
+    private getLastStreamEntities;
+}
+
+interface MariaDBSnapshotStoreConfig extends SnapshotStoreConfig, PoolConfig {
+    driver: Type<MariaDBSnapshotStore>;
+}
+
+export { type MariaDBEventEntity, MariaDBEventStore, type MariaDBEventStoreConfig, type MariaDBSnapshotEntity, MariaDBSnapshotStore, type MariaDBSnapshotStoreConfig };

package/dist/index.js

@@ -0,0 +1,716 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+
+// lib/index.ts
+var lib_exports = {};
+__export(lib_exports, {
+  MariaDBEventStore: () => MariaDBEventStore,
+  MariaDBSnapshotStore: () => MariaDBSnapshotStore
+});
+module.exports = __toCommonJS(lib_exports);
+
+// lib/mariadb.event-store.ts
+var import_event_sourcing = require("@ocoda/event-sourcing");
+var import_mariadb = require("mariadb");
+var _MariaDBEventStore = class _MariaDBEventStore extends import_event_sourcing.EventStore {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "pool");
+  }
+  connect() {
+    return __async(this, null, function* () {
+      this.logger.log("Starting store");
+      this.pool = (0, import_mariadb.createPool)(this.options);
+    });
+  }
+  disconnect() {
+    return __async(this, null, function* () {
+      this.logger.log("Stopping store");
+      yield this.pool.end();
+    });
+  }
+  ensureCollection(pool) {
+    return __async(this, null, function* () {
+      const collection = import_event_sourcing.EventCollection.get(pool);
+      try {
+        yield this.pool.query(`CREATE TABLE IF NOT EXISTS \`${collection}\` (
+                    stream_id VARCHAR(120) NOT NULL,
+                    version INT NOT NULL,
+                    event VARCHAR(80) NOT NULL,
+                    payload JSON NOT NULL,
+                    event_id VARCHAR(40) NOT NULL,
+                    aggregate_id VARCHAR(40) NOT NULL,
+                    occurred_on TIMESTAMP NOT NULL,
+                    correlation_id VARCHAR(255),
+                    causation_id VARCHAR(255),
+                    PRIMARY KEY (stream_id, version)
+                )`);
+        return collection;
+      } catch (error) {
+        throw new import_event_sourcing.EventStoreCollectionCreationException(collection, error);
+      }
+    });
+  }
+  getEvents(_0, _1) {
+    return __asyncGenerator(this, arguments, function* ({ streamId }, filter) {
+      const connection = this.pool.getConnection();
+      const collection = import_event_sourcing.EventCollection.get(filter == null ? void 0 : filter.pool);
+      const fromVersion = filter == null ? void 0 : filter.fromVersion;
+      const direction = (filter == null ? void 0 : filter.direction) || import_event_sourcing.StreamReadingDirection.FORWARD;
+      const limit = (filter == null ? void 0 : filter.limit) || Number.MAX_SAFE_INTEGER;
+      const batch = (filter == null ? void 0 : filter.batch) || import_event_sourcing.DEFAULT_BATCH_SIZE;
+      const query = `
+            SELECT event, payload
+            FROM \`${collection}\`
+            WHERE stream_id = ?
+            ${fromVersion ? "AND version >= ?" : ""}
+            ORDER BY version ${direction === import_event_sourcing.StreamReadingDirection.FORWARD ? "ASC" : "DESC"}
+            LIMIT ?
+        `;
+      const params = fromVersion ? [
+        streamId,
+        fromVersion,
+        limit
+      ] : [
+        streamId,
+        limit
+      ];
+      const client = yield new __await(connection);
+      const stream = client.queryStream(query, params);
+      try {
+        let batchedEvents = [];
+        try {
+          for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+            const { event, payload } = temp.value;
+            batchedEvents.push(this.eventMap.deserializeEvent(event, payload));
+            if (batchedEvents.length === batch) {
+              yield batchedEvents;
+              batchedEvents = [];
+            }
+          }
+        } catch (temp) {
+          error = [temp];
+        } finally {
+          try {
+            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+          } finally {
+            if (error)
+              throw error[0];
+          }
+        }
+        if (batchedEvents.length > 0) {
+          yield batchedEvents;
+        }
+      } catch (e) {
+        stream.destroy();
+      } finally {
+        yield new __await(client.release());
+      }
+    });
+  }
+  getEvent(_0, _1, _2) {
+    return __async(this, arguments, function* ({ streamId }, version, pool) {
+      const collection = import_event_sourcing.EventCollection.get(pool);
+      const [entity] = yield this.pool.query(`SELECT event, payload FROM \`${collection}\` WHERE stream_id = ? AND version = ?`, [
+        streamId,
+        version
+      ]);
+      if (!entity) {
+        throw new import_event_sourcing.EventNotFoundException(streamId, version);
+      }
+      return this.eventMap.deserializeEvent(entity.event, entity.payload);
+    });
+  }
+  appendEvents(stream, aggregateVersion, events, pool) {
+    return __async(this, null, function* () {
+      const connection = yield this.pool.getConnection();
+      const collection = import_event_sourcing.EventCollection.get(pool);
+      try {
+        const [currentVersionResult] = yield connection.query(`SELECT MAX(version) as version FROM \`${collection}\` WHERE stream_id = ?`, [
+          stream.streamId
+        ]);
+        const currentVersion = (currentVersionResult == null ? void 0 : currentVersionResult.version) || 0;
+        if (aggregateVersion <= currentVersion) {
+          throw new import_event_sourcing.EventStoreVersionConflictException(stream, aggregateVersion, currentVersion);
+        }
+        let version = aggregateVersion - events.length + 1;
+        const envelopes = [];
+        for (const event of events) {
+          const name = this.eventMap.getName(event);
+          const payload = this.eventMap.serializeEvent(event);
+          const envelope = import_event_sourcing.EventEnvelope.create(name, payload, {
+            aggregateId: stream.aggregateId,
+            version: version++
+          });
+          envelopes.push(envelope);
+        }
+        yield connection.beginTransaction();
+        yield connection.batch(`INSERT INTO \`${collection}\` VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, envelopes.map(({ event, payload, metadata }) => {
+          var _a, _b;
+          return [
+            stream.streamId,
+            metadata.version,
+            event,
+            JSON.stringify(payload),
+            metadata.eventId,
+            metadata.aggregateId,
+            metadata.occurredOn,
+            (_a = metadata.correlationId) != null ? _a : null,
+            (_b = metadata.causationId) != null ? _b : null
+          ];
+        }));
+        yield connection.commit();
+        return envelopes;
+      } catch (error) {
+        yield connection.rollback();
+        switch (error.constructor) {
+          case import_event_sourcing.EventStoreVersionConflictException:
+            throw error;
+          default:
+            throw new import_event_sourcing.EventStorePersistenceException(collection, error);
+        }
+      } finally {
+        connection.release();
+      }
+    });
+  }
+  getEnvelopes(_0, _1) {
+    return __asyncGenerator(this, arguments, function* ({ streamId }, filter) {
+      const connection = this.pool.getConnection();
+      const collection = import_event_sourcing.EventCollection.get(filter == null ? void 0 : filter.pool);
+      const fromVersion = filter == null ? void 0 : filter.fromVersion;
+      const direction = (filter == null ? void 0 : filter.direction) || import_event_sourcing.StreamReadingDirection.FORWARD;
+      const limit = (filter == null ? void 0 : filter.limit) || Number.MAX_SAFE_INTEGER;
+      const batch = (filter == null ? void 0 : filter.batch) || import_event_sourcing.DEFAULT_BATCH_SIZE;
+      const query = `
+            SELECT event, payload, event_id, aggregate_id, version, occurred_on, correlation_id, causation_id
+            FROM \`${collection}\`
+            WHERE stream_id = ?
+            ${fromVersion ? "AND version >= ?" : ""}
+            ORDER BY version ${direction === import_event_sourcing.StreamReadingDirection.FORWARD ? "ASC" : "DESC"}
+            LIMIT ?
+        `;
+      const params = fromVersion ? [
+        streamId,
+        fromVersion,
+        limit
+      ] : [
+        streamId,
+        limit
+      ];
+      const client = yield new __await(connection);
+      const stream = client.queryStream(query, params);
+      try {
+        let batchedEvents = [];
+        try {
+          for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+            const { event, payload, event_id, aggregate_id, version, occurred_on, correlation_id, causation_id } = temp.value;
+            batchedEvents.push(import_event_sourcing.EventEnvelope.from(event, payload, {
+              eventId: event_id,
+              aggregateId: aggregate_id,
+              version,
+              occurredOn: occurred_on,
+              correlationId: correlation_id,
+              causationId: causation_id
+            }));
+            if (batchedEvents.length === batch) {
+              yield batchedEvents;
+              batchedEvents = [];
+            }
+          }
+        } catch (temp) {
+          error = [temp];
+        } finally {
+          try {
+            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+          } finally {
+            if (error)
+              throw error[0];
+          }
+        }
+        if (batchedEvents.length > 0) {
+          yield batchedEvents;
+        }
+      } catch (e) {
+        stream.destroy();
+      } finally {
+        yield new __await(client.release());
+      }
+    });
+  }
+  getEnvelope(_0, _1, _2) {
+    return __async(this, arguments, function* ({ streamId }, version, pool) {
+      const collection = import_event_sourcing.EventCollection.get(pool);
+      const [entity] = yield this.pool.query(`SELECT event, payload, event_id, aggregate_id, version, occurred_on, correlation_id, causation_id FROM \`${collection}\` WHERE stream_id = ? AND version = ?`, [
+        streamId,
+        version
+      ]);
+      if (!entity) {
+        throw new import_event_sourcing.EventNotFoundException(streamId, version);
+      }
+      return import_event_sourcing.EventEnvelope.from(entity.event, entity.payload, {
+        eventId: entity.event_id,
+        aggregateId: entity.aggregate_id,
+        version: entity.version,
+        occurredOn: entity.occurred_on,
+        correlationId: entity.correlation_id,
+        causationId: entity.causation_id
+      });
+    });
+  }
+};
+__name(_MariaDBEventStore, "MariaDBEventStore");
+var MariaDBEventStore = _MariaDBEventStore;
+
+// lib/mariadb.snapshot-store.ts
+var import_event_sourcing2 = require("@ocoda/event-sourcing");
+var import_mariadb2 = require("mariadb");
+var _MariaDBSnapshotStore = class _MariaDBSnapshotStore extends import_event_sourcing2.SnapshotStore {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "pool");
+  }
+  connect() {
+    return __async(this, null, function* () {
+      this.logger.log("Starting store");
+      this.pool = (0, import_mariadb2.createPool)(this.options);
+    });
+  }
+  disconnect() {
+    return __async(this, null, function* () {
+      this.logger.log("Stopping store");
+      yield this.pool.end();
+    });
+  }
+  ensureCollection(pool) {
+    return __async(this, null, function* () {
+      const collection = import_event_sourcing2.SnapshotCollection.get(pool);
+      try {
+        yield this.pool.query(`CREATE TABLE IF NOT EXISTS \`${collection}\` (
+                    stream_id VARCHAR(90) NOT NULL,
+                    version INT NOT NULL,
+                    payload JSON NOT NULL,
+                    snapshot_id VARCHAR(40) NOT NULL,
+                    aggregate_id VARCHAR(40) NOT NULL,
+                    registered_on TIMESTAMP NOT NULL,
+                    aggregate_name VARCHAR(50) NOT NULL,
+                    latest VARCHAR(100),
+                    PRIMARY KEY (stream_id, version),
+                    INDEX idx_aggregate_name_latest (aggregate_name, latest)
+                )`);
+        return collection;
+      } catch (error) {
+        throw new import_event_sourcing2.SnapshotStoreCollectionCreationException(collection, error);
+      }
+    });
+  }
+  stop() {
+    return __async(this, null, function* () {
+      this.logger.log("Stopping store");
+      yield this.pool.end();
+    });
+  }
+  getSnapshots(_0, _1) {
+    return __asyncGenerator(this, arguments, function* ({ streamId }, filter) {
+      const connection = this.pool.getConnection();
+      const collection = import_event_sourcing2.SnapshotCollection.get(filter == null ? void 0 : filter.pool);
+      const fromVersion = filter == null ? void 0 : filter.fromVersion;
+      const direction = (filter == null ? void 0 : filter.direction) || import_event_sourcing2.StreamReadingDirection.FORWARD;
+      const limit = (filter == null ? void 0 : filter.limit) || Number.MAX_SAFE_INTEGER;
+      const batch = (filter == null ? void 0 : filter.batch) || import_event_sourcing2.DEFAULT_BATCH_SIZE;
+      const query = `
+	        SELECT payload
+	        FROM \`${collection}\`
+	        WHERE stream_id = ?
+	        ${fromVersion ? "AND version >= ?" : ""}
+	        ORDER BY version ${direction === import_event_sourcing2.StreamReadingDirection.FORWARD ? "ASC" : "DESC"}
+	        LIMIT ?
+	    `;
+      const params = fromVersion ? [
+        streamId,
+        fromVersion,
+        limit
+      ] : [
+        streamId,
+        limit
+      ];
+      const client = yield new __await(connection);
+      const stream = client.queryStream(query, params);
+      try {
+        let batchedEvents = [];
+        try {
+          for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+            const { payload } = temp.value;
+            batchedEvents.push(payload);
+            if (batchedEvents.length === batch) {
+              yield batchedEvents;
+              batchedEvents = [];
+            }
+          }
+        } catch (temp) {
+          error = [temp];
+        } finally {
+          try {
+            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+          } finally {
+            if (error)
+              throw error[0];
+          }
+        }
+        if (batchedEvents.length > 0) {
+          yield batchedEvents;
+        }
+      } catch (e) {
+        stream.destroy();
+      } finally {
+        yield new __await(client.release());
+      }
+    });
+  }
+  getSnapshot(_0, _1, _2) {
+    return __async(this, arguments, function* ({ streamId }, version, pool) {
+      const collection = import_event_sourcing2.SnapshotCollection.get(pool);
+      const [entity] = yield this.pool.query(`SELECT payload FROM \`${collection}\` WHERE stream_id = ? AND version = ?`, [
+        streamId,
+        version
+      ]);
+      if (!entity) {
+        throw new import_event_sourcing2.SnapshotNotFoundException(streamId, version);
+      }
+      return entity.payload;
+    });
+  }
+  appendSnapshot(stream, aggregateVersion, snapshot, pool) {
+    return __async(this, null, function* () {
+      const connection = yield this.pool.getConnection();
+      const collection = import_event_sourcing2.SnapshotCollection.get(pool);
+      try {
+        const envelope = import_event_sourcing2.SnapshotEnvelope.create(snapshot, {
+          aggregateId: stream.aggregateId,
+          version: aggregateVersion
+        });
+        const [lastStreamEntity] = yield this.getLastStreamEntities(collection, [
+          stream
+        ], [
+          "stream_id",
+          "version"
+        ], connection);
+        if (aggregateVersion <= (lastStreamEntity == null ? void 0 : lastStreamEntity.version)) {
+          throw new import_event_sourcing2.SnapshotStoreVersionConflictException(stream, aggregateVersion, lastStreamEntity.version);
+        }
+        yield connection.beginTransaction();
+        if (lastStreamEntity) {
+          yield connection.query(`UPDATE \`${collection}\` SET latest = null WHERE stream_id = ? AND version = ?`, [
+            lastStreamEntity.stream_id,
+            lastStreamEntity.version
+          ]);
+        }
+        yield connection.query(`INSERT INTO \`${collection}\` VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+          stream.streamId,
+          envelope.metadata.version,
+          JSON.stringify(envelope.payload),
+          envelope.metadata.snapshotId,
+          envelope.metadata.aggregateId,
+          envelope.metadata.registeredOn,
+          stream.aggregate,
+          `latest#${stream.streamId}`
+        ]);
+        yield connection.commit();
+        return envelope;
+      } catch (error) {
+        yield connection.rollback();
+        switch (error.constructor) {
+          case import_event_sourcing2.SnapshotStoreVersionConflictException:
+            throw error;
+          default:
+            throw new import_event_sourcing2.SnapshotStorePersistenceException(collection, error);
+        }
+      } finally {
+        connection.release();
+      }
+    });
+  }
+  getLastSnapshot(stream, pool) {
+    return __async(this, null, function* () {
+      const collection = import_event_sourcing2.SnapshotCollection.get(pool);
+      const [entity] = yield this.getLastStreamEntities(collection, [
+        stream
+      ], [
+        "payload"
+      ]);
+      if (entity) {
+        return entity.payload;
+      }
+    });
+  }
+  getManyLastSnapshots(streams, pool) {
+    return __async(this, null, function* () {
+      const collection = import_event_sourcing2.SnapshotCollection.get(pool);
+      const entities = yield this.getLastStreamEntities(collection, streams, [
+        "stream_id",
+        "payload"
+      ]);
+      return new Map(entities.map(({ stream_id, payload }) => [
+        streams.find(({ streamId: currentStreamId }) => currentStreamId === stream_id),
+        payload
+      ]));
+    });
+  }
+  getLastEnvelope(stream, pool) {
+    return __async(this, null, function* () {
+      const collection = import_event_sourcing2.SnapshotCollection.get(pool);
+      const [entity] = yield this.getLastStreamEntities(collection, [
+        stream
+      ], [
+        "payload",
+        "snapshot_id",
+        "aggregate_id",
+        "registered_on",
+        "version"
+      ]);
+      if (entity) {
+        return import_event_sourcing2.SnapshotEnvelope.from(entity.payload, {
+          snapshotId: entity.snapshot_id,
+          aggregateId: entity.aggregate_id,
+          registeredOn: entity.registered_on,
+          version: entity.version
+        });
+      }
+    });
+  }
+  getEnvelopes(_0, _1) {
+    return __asyncGenerator(this, arguments, function* ({ streamId }, filter) {
+      const connection = this.pool.getConnection();
+      const collection = import_event_sourcing2.SnapshotCollection.get(filter == null ? void 0 : filter.pool);
+      const fromVersion = filter == null ? void 0 : filter.fromVersion;
+      const direction = (filter == null ? void 0 : filter.direction) || import_event_sourcing2.StreamReadingDirection.FORWARD;
+      const limit = (filter == null ? void 0 : filter.limit) || Number.MAX_SAFE_INTEGER;
+      const batch = (filter == null ? void 0 : filter.batch) || import_event_sourcing2.DEFAULT_BATCH_SIZE;
+      const query = `
+	        SELECT payload, aggregate_id, registered_on, snapshot_id, version
+	        FROM \`${collection}\`
+	        WHERE stream_id = ?
+	        ${fromVersion ? "AND version >= ?" : ""}
+	        ORDER BY version ${direction === import_event_sourcing2.StreamReadingDirection.FORWARD ? "ASC" : "DESC"}
+	        LIMIT ?
+	    `;
+      const params = fromVersion ? [
+        streamId,
+        fromVersion,
+        limit
+      ] : [
+        streamId,
+        limit
+      ];
+      const client = yield new __await(connection);
+      const stream = client.queryStream(query, params);
+      try {
+        let batchedSnapshots = [];
+        try {
+          for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+            const { payload, aggregate_id, registered_on, snapshot_id, version } = temp.value;
+            batchedSnapshots.push(import_event_sourcing2.SnapshotEnvelope.from(payload, {
+              aggregateId: aggregate_id,
+              registeredOn: registered_on,
+              snapshotId: snapshot_id,
+              version
+            }));
+            if (batchedSnapshots.length === batch) {
+              yield batchedSnapshots;
+              batchedSnapshots = [];
+            }
+          }
+        } catch (temp) {
+          error = [temp];
+        } finally {
+          try {
+            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+          } finally {
+            if (error)
+              throw error[0];
+          }
+        }
+        if (batchedSnapshots.length > 0) {
+          yield batchedSnapshots;
+        }
+      } catch (e) {
+        stream.destroy();
+      } finally {
+        yield new __await(client.release());
+      }
+    });
+  }
+  getEnvelope(_0, _1, _2) {
+    return __async(this, arguments, function* ({ streamId }, version, pool) {
+      const collection = import_event_sourcing2.SnapshotCollection.get(pool);
+      const [entity] = yield this.pool.query(`SELECT payload, aggregate_id, registered_on, snapshot_id, version FROM \`${collection}\` WHERE stream_id = ? AND version = ?`, [
+        streamId,
+        version
+      ]);
+      if (!entity) {
+        throw new import_event_sourcing2.SnapshotNotFoundException(streamId, version);
+      }
+      return import_event_sourcing2.SnapshotEnvelope.from(entity.payload, {
+        aggregateId: entity.aggregate_id,
+        registeredOn: entity.registered_on,
+        snapshotId: entity.snapshot_id,
+        version: entity.version
+      });
+    });
+  }
+  getLastAggregateEnvelopes(aggregateName, filter) {
+    return __asyncGenerator(this, null, function* () {
+      const connection = this.pool.getConnection();
+      const collection = import_event_sourcing2.SnapshotCollection.get(filter == null ? void 0 : filter.pool);
+      const fromId = filter == null ? void 0 : filter.fromId;
+      const limit = (filter == null ? void 0 : filter.limit) || Number.MAX_SAFE_INTEGER;
+      const batch = (filter == null ? void 0 : filter.batch) || import_event_sourcing2.DEFAULT_BATCH_SIZE;
+      const query = `
+	        SELECT payload, aggregate_id, registered_on, snapshot_id, version
+	        FROM \`${collection}\`
+	        WHERE aggregate_name = ?
+	        AND ${fromId ? "latest >= ?" : "latest LIKE 'latest%'"}
+	        LIMIT ?
+	    `;
+      const params = fromId ? [
+        aggregateName,
+        fromId,
+        limit
+      ] : [
+        aggregateName,
+        limit
+      ];
+      const client = yield new __await(connection);
+      const stream = client.queryStream(query, params);
+      try {
+        let batchedSnapshots = [];
+        try {
+          for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+            const { payload, aggregate_id, registered_on, snapshot_id, version } = temp.value;
+            batchedSnapshots.push(import_event_sourcing2.SnapshotEnvelope.from(payload, {
+              aggregateId: aggregate_id,
+              registeredOn: registered_on,
+              snapshotId: snapshot_id,
+              version
+            }));
+            if (batchedSnapshots.length === batch) {
+              yield batchedSnapshots;
+              batchedSnapshots = [];
+            }
+          }
+        } catch (temp) {
+          error = [temp];
+        } finally {
+          try {
+            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+          } finally {
+            if (error)
+              throw error[0];
+          }
+        }
+        if (batchedSnapshots.length > 0) {
+          yield batchedSnapshots;
+        }
+      } catch (e) {
+        stream.destroy();
+      } finally {
+        yield new __await(client.release());
+      }
+    });
+  }
+  getManyLastSnapshotEnvelopes(streams, pool) {
+    return __async(this, null, function* () {
+      const collection = import_event_sourcing2.SnapshotCollection.get(pool);
+      const entities = yield this.getLastStreamEntities(collection, streams, [
+        "stream_id",
+        "payload",
+        "aggregate_id",
+        "registered_on",
+        "snapshot_id",
+        "version"
+      ]);
+      return new Map(entities.map(({ stream_id, payload, aggregate_id, registered_on, snapshot_id, version }) => [
+        streams.find(({ streamId: currentStreamId }) => currentStreamId === stream_id),
+        import_event_sourcing2.SnapshotEnvelope.from(payload, {
+          aggregateId: aggregate_id,
+          registeredOn: new Date(registered_on),
+          snapshotId: snapshot_id,
+          version
+        })
+      ]));
+    });
+  }
+  getLastStreamEntities(collection, streams, fields, connection) {
+    return __async(this, null, function* () {
+      const latestIds = streams.map(({ streamId }) => `latest#${streamId}`);
+      return (connection || this.pool).query(`SELECT ${fields.join(", ")} 
+                FROM \`${collection}\` 
+                WHERE latest IN (?)
+            `, [
+        latestIds
+      ]);
+    });
+  }
+};
+__name(_MariaDBSnapshotStore, "MariaDBSnapshotStore");
+var MariaDBSnapshotStore = _MariaDBSnapshotStore;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MariaDBEventStore,
+  MariaDBSnapshotStore
+});

package/index.d.ts

@@ -0,0 +1 @@
+export * from './dist';

package/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dist"), exports);

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@ocoda/event-sourcing-mariadb",
+  "version": "1.0.0",
+  "description": "NestJS Event Sourcing Library (@mariadb)",
+  "author": "Dries Hooghe <dries@drieshooghe.com>",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bugs": {
+    "url": "https://github.com/ocoda/event-sourcing/issues"
+  },
+  "engines": {
+    "node": ">= 18.0.0"
+  },
+  "dependencies": {
+    "mariadb": "^3.3.1"
+  },
+  "peerDependencies": {
+    "@nestjs/core": "^10.0.0",
+    "reflect-metadata": "^0.2.0",
+    "rxjs": "^7.2.0",
+    "@ocoda/event-sourcing": "1.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "1.9.3",
+    "@faker-js/faker": "^9.0.0",
+    "@nestjs/common": "10.4.4",
+    "@nestjs/core": "10.4.4",
+    "@nestjs/platform-express": "10.4.4",
+    "@nestjs/testing": "10.4.4",
+    "@swc-node/register": "^1.5.2",
+    "@swc/core": "1.7.26",
+    "@swc/jest": "0.2.36",
+    "@types/jest": "29.5.13",
+    "@types/node": "20.16.10",
+    "jest": "29.7.0",
+    "jest-mock": "29.7.0",
+    "reflect-metadata": "0.2.2",
+    "rxjs": "7.8.1",
+    "tsup": "^8.3.0",
+    "typescript": "5.6.2",
+    "@ocoda/event-sourcing-config": "1.0.0",
+    "@ocoda/event-sourcing-testing": "1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ocoda/event-sourcing",
+    "directory": "packages/integration/mariadb"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsup lib/index.ts --format cjs --dts",
+    "test": "jest --config jest.config.js",
+    "test:ci": "jest --config jest.config.js --runInBand --coverage",
+    "ci": "biome ci",
+    "format": "biome format --write",
+    "lint": "biome check --write"
+  }
+}