tapeworm 0.5.0 → 0.6.0

package/src/persistence/inmemory/inmemory_partition.ts

@@ -0,0 +1,194 @@
+import Promise from "bluebird";
+import _ from "lodash";
+import type { ICommit, ISnapshot, NodeCallback } from "../../types";
+import ConcurrencyError from "../concurrency_error";
+import DuplicateCommitError from "../duplicate_commit_error";
+
+interface IInMemoryPartition {
+  _commits: ICommit[];
+  _streamIndex: Record<string, ICommit[]>;
+  _commitIds: string[];
+  _commitConcurrencyCheck: string[];
+  _snapshots: Record<string, ISnapshot>;
+  _promisify<T>(value: T, callback?: NodeCallback<T>): Promise<T>;
+  truncateStreamFrom(streamId: string, commitSequence: number, remove?: boolean | NodeCallback<void>, callback?: NodeCallback<void>): Promise<void>;
+  applyCommitHeader(commitId: string, header: Record<string, unknown>, callback?: NodeCallback<ICommit>): Promise<ICommit>;
+  append(commit: ICommit, callback?: NodeCallback<ICommit>): Promise<ICommit>;
+  storeSnapshot(streamId: string, snapshot: Record<string, unknown> | undefined, version: number, callback?: NodeCallback<ISnapshot>): Promise<ISnapshot>;
+  loadSnapshot(streamId: string, callback?: NodeCallback<ISnapshot | undefined>): Promise<ISnapshot | undefined>;
+  markAsDispatched(commit: ICommit, callback?: NodeCallback<ICommit>): Promise<ICommit>;
+  getUndispatched(callback?: NodeCallback<ICommit[]>): Promise<ICommit[]>;
+  queryAll(callback?: NodeCallback<ICommit[]>): Promise<ICommit[]>;
+  getLatestCommit(streamId: string, callback?: NodeCallback<ICommit | undefined>): Promise<ICommit | undefined>;
+  queryStream(streamId: string, fromEventSequence?: number | NodeCallback<ICommit[]>, callback?: NodeCallback<ICommit[]>): Promise<ICommit[]>;
+}
+
+var InMemoryPartition = function (this: IInMemoryPartition) {
+  this._commits = [];
+  this._streamIndex = {};
+  this._commitIds = [];
+  this._commitConcurrencyCheck = [];
+  this._snapshots = {};
+} as unknown as new () => IInMemoryPartition;
+
+function getConcurrencyKey(commit: ICommit): string {
+  return commit.streamId + "-" + commit.commitSequence;
+}
+
+InMemoryPartition.prototype._promisify = function <T>(this: IInMemoryPartition, value: T, callback?: NodeCallback<T>): Promise<T> {
+  return Promise.resolve(value).nodeify(callback);
+};
+
+InMemoryPartition.prototype.truncateStreamFrom = function (
+  this: IInMemoryPartition,
+  streamId: string,
+  commitSequence: number,
+  remove?: boolean | NodeCallback<void>,
+  callback?: NodeCallback<void>
+) {
+  if (typeof remove === "function") {
+    callback = remove;
+  }
+  var self = this;
+  var commits = Array.from(this._streamIndex[streamId]);
+  for (var i = 0; i < commits.length; i++) {
+    var commit = commits[i];
+
+    if (commit.commitSequence >= commitSequence) {
+      //remove from commitId
+      self._commitIds = _.without(self._commitIds, commit.id);
+      self._commitConcurrencyCheck = _.without(self._commitConcurrencyCheck, getConcurrencyKey(commit));
+      self._commits = _.without(self._commits, commit);
+    }
+  }
+  commits = commits.slice(0, Math.max(commitSequence, 0));
+  this._streamIndex[streamId] = commits;
+  return this._promisify(undefined as unknown as undefined, callback);
+};
+
+InMemoryPartition.prototype.applyCommitHeader = function (
+  this: IInMemoryPartition,
+  commitId: string,
+  header: Record<string, unknown>,
+  callback?: NodeCallback<ICommit>
+) {
+  var commit = _.find(this._commits, { id: commitId });
+  if (commit) {
+    _.assign(commit, header);
+  } else {
+    throw new Error("Trying to apply header to missing commit: " + commitId);
+  }
+  return this._promisify(commit, callback);
+};
+
+InMemoryPartition.prototype.append = function (this: IInMemoryPartition, commit: ICommit, callback?: NodeCallback<ICommit>) {
+  commit.isDispatched = false;
+  //check for duplicates
+  if (_.includes(this._commitIds, commit.id)) {
+    throw new DuplicateCommitError("Duplicate commit of " + commit.id);
+  }
+  var concurrencyKey = getConcurrencyKey(commit);
+  if (_.includes(this._commitConcurrencyCheck, concurrencyKey)) {
+    throw new ConcurrencyError("Concurrency error on stream " + commit.streamId);
+  }
+  //check concurrency
+  this._commits.push(commit);
+  this._commitIds.push(commit.id);
+  this._commitConcurrencyCheck.push(concurrencyKey);
+  var index = this._streamIndex[commit.streamId];
+  if (!index) {
+    index = this._streamIndex[commit.streamId] = [];
+  }
+  index.push(commit);
+  return this._promisify(commit, callback);
+};
+
+InMemoryPartition.prototype.storeSnapshot = function (
+  this: IInMemoryPartition,
+  streamId: string,
+  snapshot: Record<string, unknown> | undefined,
+  version: number,
+  callback?: NodeCallback<ISnapshot>
+) {
+  return this._promisify(
+    (this._snapshots[streamId] = {
+      id: streamId,
+      version: version,
+      snapshot: snapshot,
+    }),
+    callback
+  );
+};
+
+// Loads the latest snapshot
+InMemoryPartition.prototype.loadSnapshot = function (this: IInMemoryPartition, streamId: string, callback?: NodeCallback<ISnapshot | undefined>) {
+  return this._promisify(this._snapshots[streamId], callback);
+};
+
+InMemoryPartition.prototype.markAsDispatched = function (this: IInMemoryPartition, commit: ICommit, callback?: NodeCallback<ICommit>) {
+  commit.isDispatched = true;
+  return this._promisify(commit, callback);
+};
+
+InMemoryPartition.prototype.getUndispatched = function (this: IInMemoryPartition, callback?: NodeCallback<ICommit[]>) {
+  var commits = this._commits;
+  var undispatched: ICommit[] = [];
+  for (var i = 0; i < commits.length; i++) {
+    if (!commits[i].isDispatched) {
+      undispatched.push(commits[i]);
+    }
+  }
+  return this._promisify(undispatched, callback);
+};
+
+InMemoryPartition.prototype.queryAll = function (this: IInMemoryPartition, callback?: NodeCallback<ICommit[]>) {
+  return this._promisify(this._commits.slice(), callback);
+};
+
+InMemoryPartition.prototype.getLatestCommit = function (this: IInMemoryPartition, streamId: string, callback?: NodeCallback<ICommit | undefined>) {
+  var result = this._streamIndex[streamId];
+  if (result) {
+    return this._promisify(result.slice().pop(), callback);
+  }
+  return this._promisify(undefined as ICommit | undefined, callback);
+};
+
+InMemoryPartition.prototype.queryStream = function (
+  this: IInMemoryPartition,
+  streamId: string,
+  fromEventSequence?: number | NodeCallback<ICommit[]>,
+  callback?: NodeCallback<ICommit[]>
+) {
+  if (_.isFunction(fromEventSequence)) {
+    callback = fromEventSequence as NodeCallback<ICommit[]>;
+    fromEventSequence = 0;
+  }
+  var result = this._streamIndex[streamId];
+
+  if (result) {
+    var sliced = result.slice();
+    if ((fromEventSequence as number) > 0) {
+      var startCommitId = 0;
+      var foundEvents = 0;
+      for (var i = 0; i < sliced.length; i++) {
+        foundEvents += sliced[0].events.length;
+        startCommitId++;
+        if (foundEvents >= (fromEventSequence as number)) {
+          break;
+        }
+      }
+      var tooMany = foundEvents - (fromEventSequence as number);
+
+      sliced = sliced.slice(startCommitId - (tooMany > 0 ? 1 : 0));
+      if (tooMany > 0) {
+        sliced[0] = _.clone(sliced[0]); // avoid modifying reference
+        sliced[0].events = sliced[0].events.slice(sliced[0].events.length - tooMany);
+      }
+    }
+    return this._promisify(sliced, callback);
+  }
+
+  return this._promisify(result as ICommit[], callback);
+};
+
+export default InMemoryPartition;

package/src/persistence/inmemory/inmemory_persistence.ts

@@ -0,0 +1,35 @@
+import Promise from "bluebird";
+import type { NodeCallback } from "../../types";
+import Partition from "./inmemory_partition";
+
+type InMemoryPartitionInstance = InstanceType<typeof Partition>;
+
+interface IInMemoryPersistence {
+  _partitions: Record<string, InMemoryPartitionInstance>;
+  _promisify<T>(value: T, callback?: NodeCallback<T>): Promise<T>;
+  openPartition(partitionId?: string, callback?: NodeCallback<InMemoryPartitionInstance>): Promise<InMemoryPartitionInstance>;
+  _getPartition(partitionId?: string): InMemoryPartitionInstance;
+}
+
+var InMemoryPersistence = function InMemoryPersistance(this: IInMemoryPersistence) {
+  this._partitions = {};
+} as unknown as new () => IInMemoryPersistence;
+
+InMemoryPersistence.prototype._promisify = function <T>(this: IInMemoryPersistence, value: T, callback?: NodeCallback<T>): Promise<T> {
+  return Promise.resolve(value).nodeify(callback);
+};
+
+InMemoryPersistence.prototype.openPartition = function (this: IInMemoryPersistence, partitionId?: string, callback?: NodeCallback<InMemoryPartitionInstance>) {
+  return this._promisify(this._getPartition(partitionId), callback);
+};
+
+InMemoryPersistence.prototype._getPartition = function (this: IInMemoryPersistence, partitionId?: string): InMemoryPartitionInstance {
+  var currentPartitionId = partitionId || "master";
+  var partition = this._partitions[currentPartitionId];
+  if (partition == null) {
+    partition = this._partitions[currentPartitionId] = new Partition();
+  }
+  return partition;
+};
+
+export default InMemoryPersistence;

package/src/persistence/persistence_partition.ts

@@ -0,0 +1,34 @@
+import type { ICommit, NodeCallback } from "../types";
+
+interface IPersistencePartitionTemplate {
+  append(_commit: ICommit, _callback?: NodeCallback<ICommit>): void;
+  getUndispatched(_callback?: NodeCallback<ICommit[]>): void;
+  markAsDispatched(_commit: ICommit, _callback?: NodeCallback<void>): void;
+  queryAll(_callback?: NodeCallback<ICommit[]>): void;
+  queryStream(_streamId: string, _callback?: NodeCallback<ICommit[]>): void;
+}
+
+/** Abstract template — subclasses must override all methods. */
+var PersistencePartition = function () {} as unknown as new () => IPersistencePartitionTemplate;
+
+PersistencePartition.prototype.append = function (_commit: ICommit, _callback?: NodeCallback<ICommit>) {
+  //add commit
+};
+
+PersistencePartition.prototype.getUndispatched = function (_callback?: NodeCallback<ICommit[]>) {
+  //return events which are not dispatched
+};
+
+PersistencePartition.prototype.markAsDispatched = function (_commit: ICommit, _callback?: NodeCallback<void>) {
+  //return events which are not dispatched
+};
+
+PersistencePartition.prototype.queryAll = function (_callback?: NodeCallback<ICommit[]>) {
+  //return Query
+};
+
+PersistencePartition.prototype.queryStream = function (_streamId: string, _callback?: NodeCallback<ICommit[]>) {
+  //return Query;
+};
+
+export default PersistencePartition;

package/src/persistence/persistence_provider_template.ts

@@ -0,0 +1,20 @@
+import type { NodeCallback } from "../types";
+
+interface IPersistenceProviderTemplate {
+  openPartition(_partitionId?: string, _callback?: NodeCallback<unknown>): void;
+  deletePartition(_partitionId?: string, _callback?: NodeCallback<void>): void;
+  close(_callback?: NodeCallback<void>): void;
+}
+
+/** Abstract template — subclasses must override all methods. */
+var PersistenceProvider = function () {} as unknown as new () => IPersistenceProviderTemplate;
+
+PersistenceProvider.prototype.openPartition = function (_partitionId?: string, _callback?: NodeCallback<unknown>) {
+  // body...
+};
+
+PersistenceProvider.prototype.deletePartition = function (_partitionId?: string, _callback?: NodeCallback<void>) {};
+
+PersistenceProvider.prototype.close = function (_callback?: NodeCallback<void>) {};
+
+export default PersistenceProvider;

package/src/replication/master_replication_service.ts

@@ -0,0 +1,12 @@
+interface IMasterReplicationService {
+  handle(_first_argument: unknown): void;
+}
+
+/** Abstract template — subclasses must override handle. */
+var MasterReplicatonService = function () {} as unknown as new () => IMasterReplicationService;
+
+MasterReplicatonService.prototype.handle = function (_first_argument: unknown) {
+  // body...
+};
+
+export default MasterReplicatonService;

package/src/types.ts

@@ -0,0 +1,128 @@
+import type Bluebird from "bluebird";
+
+/**
+ * Node-style error-first callback.
+ */
+export type NodeCallback<T> = (err: Error | null, result?: T) => void;
+
+/**
+ * Minimum event contract that tapeworm requires.
+ * Tapeworm reads `type` for delete detection and manages `version` internally.
+ * All other fields (payload, aggregateId, etc.) pass through untouched.
+ */
+export interface IBaseEvent {
+  id: string;
+  type: string;
+  version?: number;
+  [key: string]: unknown;
+}
+
+/**
+ * A commit groups one or more events for atomic persistence.
+ */
+export interface ICommit<TEvent extends IBaseEvent = IBaseEvent> {
+  id: string;
+  partitionId: string;
+  streamId: string;
+  commitSequence: number;
+  events: TEvent[];
+  isDispatched?: boolean;
+  [key: string]: unknown;
+}
+
+/**
+ * Snapshot of aggregate state at a point in time.
+ */
+export interface ISnapshot {
+  id: string;
+  version: number;
+  snapshot?: Record<string, unknown>;
+  storedDateTime?: string;
+}
+
+/**
+ * The persistence partition interface that all store implementations must satisfy.
+ * Methods marked optional are only implemented by some stores.
+ */
+export interface IPersistencePartition<TEvent extends IBaseEvent = IBaseEvent> {
+  append(
+    commit: ICommit<TEvent>,
+    callback?: NodeCallback<ICommit<TEvent>>,
+  ): Bluebird<ICommit<TEvent>>;
+  queryAll(
+    callback?: NodeCallback<ICommit<TEvent>[]>,
+  ): Bluebird<ICommit<TEvent>[]>;
+  queryStream(
+    streamId: string,
+    fromEventSequence?: number | NodeCallback<ICommit<TEvent>[]>,
+    callback?: NodeCallback<ICommit<TEvent>[]>,
+  ): Bluebird<ICommit<TEvent>[]>;
+  getUndispatched(
+    callback?: NodeCallback<ICommit<TEvent>[]>,
+  ): Bluebird<ICommit<TEvent>[]>;
+  markAsDispatched(
+    commit: ICommit<TEvent>,
+    callback?: NodeCallback<ICommit<TEvent>>,
+  ): Bluebird<ICommit<TEvent>>;
+
+  // Optional methods — implemented by some stores
+  storeSnapshot?(
+    streamId: string,
+    snapshot: Record<string, unknown> | undefined,
+    version: number,
+    callback?: NodeCallback<ISnapshot>,
+  ): Bluebird<ISnapshot>;
+  loadSnapshot?(
+    streamId: string,
+    callback?: NodeCallback<ISnapshot | undefined>,
+  ): Bluebird<ISnapshot | undefined>;
+  removeSnapshot?(
+    streamId: string,
+    callback?: NodeCallback<void>,
+  ): Bluebird<void>;
+  removeSnapshots?(
+    streamIds: string[],
+    callback?: NodeCallback<void>,
+  ): Bluebird<void>;
+  getLatestCommit?(
+    streamId: string,
+    callback?: NodeCallback<ICommit<TEvent> | undefined>,
+  ): Bluebird<ICommit<TEvent> | undefined>;
+  truncateStreamFrom?(
+    streamId: string,
+    commitSequence: number,
+    remove?: boolean | NodeCallback<void>,
+    callback?: NodeCallback<void>,
+  ): Bluebird<void>;
+  applyCommitHeader?(
+    commitId: string,
+    header: Record<string, unknown>,
+    callback?: NodeCallback<ICommit<TEvent>>,
+  ): Bluebird<ICommit<TEvent>>;
+  queryStreamWithSnapshot?(
+    streamId: string,
+    callback?: NodeCallback<unknown>,
+  ): Bluebird<unknown>;
+  querySnapshotsByMaxDateTime?(
+    dateTime: string,
+    callback?: NodeCallback<ISnapshot[]>,
+  ): Bluebird<ISnapshot[]>;
+}
+
+/**
+ * Top-level persistence provider — manages partitions.
+ */
+export interface IPersistenceProvider<TEvent extends IBaseEvent = IBaseEvent> {
+  openPartition(
+    partitionId?: string,
+    callback?: NodeCallback<IPersistencePartition<TEvent>>,
+  ): Bluebird<IPersistencePartition<TEvent>>;
+}
+
+/**
+ * Dispatch handler for publishing committed events.
+ */
+export type DispatchHandler<TEvent extends IBaseEvent = IBaseEvent> = (
+  commit: ICommit<TEvent>,
+  done?: () => void,
+) => void;

package/test/event_partition.ts

@@ -0,0 +1,151 @@
+import { v4 as uuid } from "uuid";
+import { describe, expect, it } from "vitest";
+import EventStore, { Commit } from "..";
+
+describe("Partition", () => {
+  describe("#append", () => {
+    it("should return commit if added", async (done) => {
+      const es = new EventStore();
+      const partition = await es.openPartition("location");
+      const c = await partition.append(new Commit("1", "location", "1", 0, []));
+      expect(c[0].events).toHaveLength(0);
+    });
+
+    it("should return after all commits are persisted", async () => {
+      const es = new EventStore();
+      const partition = await es.openPartition("location");
+      const c = await partition.append([new Commit("1", "location", "1", 0, []), new Commit("2", "location", "1", 1, [])]);
+      expect(c).toHaveLength(2);
+    });
+  });
+
+  describe("#_truncateStreamFrom", () => {
+    it("should remove all commits ", async () => {
+      const es = new EventStore();
+      const partition = await es.openPartition("location");
+      await partition.append([new Commit("1", "location", "1", 0, []), new Commit("2", "location", "1", 1, [])]);
+      await partition._truncateStreamFrom("1", 0);
+      const stream = await partition.openStream("1");
+      expect(stream.getVersion()).toBe(-1);
+    });
+
+    it("should remove all commits after commitSequence", async () => {
+      const es = new EventStore();
+      const partition = await es.openPartition("location");
+      await partition.append([new Commit("1", "location", "1", 0, [{}]), new Commit("2", "location", "1", 1, [{}])]);
+      await partition._truncateStreamFrom("1", 1);
+      const stream = await partition.openStream("1");
+      expect(stream.getVersion()).toBe(1);
+    });
+  });
+
+  describe("#_applyCommitHeader", () => {
+    it("should add to commit ", async () => {
+      const es = new EventStore();
+      const partition = await es.openPartition("location");
+      let commit = new Commit("1", "location", "1", 0, []);
+      await partition.append([commit, new Commit("2", "location", "1", 1, [])]);
+      commit = await partition._applyCommitHeader(commit.id, {
+        authorative: true,
+      });
+      expect(commit.authorative).toBeTruthy();
+    });
+
+    it("should throw if commit id is unknown", async () => {
+      const es = new EventStore();
+      const partition = await es.openPartition("location");
+      const commit = new Commit("1", "location", "1", 0, []);
+      await partition.append([commit, new Commit("2", "location", "1", 1, [])]);
+
+      expect(() => partition._applyCommitHeader("ID MISSING", { authorative: true })).toThrow("Trying to apply header to missing commit: ID MISSING");
+    });
+  });
+
+  describe("#queryStreamWithSnapshot", () => {
+    it("queryStreamWithSnapshot should return snapshot and missing commits", async () => {
+      const es = new EventStore();
+      const streamId = "1";
+      const stream = await es.openPartition("location").call("openStream", streamId);
+
+      stream.append({ event: "123" });
+      stream.append({ event: "999" });
+      await stream.commit(uuid());
+
+      stream.append({ event: "666" });
+      stream.append({ event: "777" });
+      await stream.commit(uuid());
+
+      const part = await es.openPartition("location");
+      part.storeSnapshot(streamId, { test: "snapshot" }, 2);
+      const res = await part.queryStreamWithSnapshot(streamId);
+
+      expect(res.snapshot.version).toBe(2);
+      expect(res.commits).toHaveLength(1);
+      expect(res.commits[0].events).toHaveLength(2);
+      expect(res.commits[0].events[0].version).toBe(2);
+    });
+
+    it("queryStreamWithSnapshot should return snapshot and no commit if up to date", async () => {
+      const es = new EventStore();
+      const streamId = "1";
+      const stream = await es.openPartition("location").call("openStream", streamId);
+
+      stream.append({ event: "123" });
+      stream.append({ event: "999" });
+      await stream.commit(uuid());
+
+      const part = await es.openPartition("location");
+      part.storeSnapshot(streamId, { test: "snapshot" }, 2);
+
+      const res = await part.queryStreamWithSnapshot(streamId);
+      expect(res.snapshot.version).toBe(2);
+      expect(res.commits).toHaveLength(0);
+    });
+  });
+
+  describe("#delete", () => {
+    it("should delete stream and all commits", async () => {
+      let didIGetaDeleteEvent = false;
+
+      const es = new EventStore(null, (commit) => {
+        if (commit.events[0].type === "$stream.deleted.event") {
+          didIGetaDeleteEvent = true;
+        }
+      });
+
+      const partition = await es.openPartition("location");
+      await partition.append([new Commit("1", "location", "1", 0, [{ type: "dummy.event" }]), new Commit("2", "location", "1", 1, [{ type: "dummy2.event" }])]);
+      await partition.delete("1", {
+        some: "header-value",
+        payload: { test: true },
+        type: "fail",
+      });
+
+      await expect(partition.openStream("1")).rejects.toThrow("Stream is deleted");
+      expect(didIGetaDeleteEvent).toBeTruthy();
+    });
+
+    it("should delete and placeholder commit should have an id", async () => {
+      let didIGetaDeleteEvent = false;
+
+      const es = new EventStore(null, (commit) => {
+        if (commit.events[0].type === "$stream.deleted.event" && commit.id) {
+          didIGetaDeleteEvent = true;
+        }
+
+        expect(commit.id).not.toBeNull();
+      });
+
+      const partition = await es.openPartition("location");
+      await partition.append([new Commit("1", "location", "1", 0, [{ type: "dummy.event" }]), new Commit("2", "location", "1", 1, [{ type: "dummy2.event" }])]);
+      await partition.delete("1", {
+        some: "header-value",
+        payload: { test: true },
+        type: "fail",
+      });
+
+      await expect(partition.openStream("1")).rejects.toThrow("Stream is deleted");
+      expect(didIGetaDeleteEvent).toBeTruthy();
+    });
+  });
+});

package/test/event_store.ts

@@ -0,0 +1,25 @@
+import Promise from "bluebird";
+import { describe, expect, it } from "vitest";
+import EventStore from "..";
+
+describe("event_store", () => {
+  describe("#openPartition", () => {
+    it("should return non null partition when using new id", async () => {
+      const es = new EventStore();
+      const partition = await es.openPartition("location");
+      expect(partition).not.toBeNull();
+    });
+
+    it("should return same instance when called multiple times", async () => {
+      const es = new EventStore();
+      const [p1, p2] = await Promise.all([es.openPartition("location"), es.openPartition("location")]);
+      expect(p1).toBe(p2);
+    });
+
+    it("should return different instances for different partitionIds", async () => {
+      const es = new EventStore();
+      const [p1, p2] = await Promise.all([es.openPartition("location"), es.openPartition("location2")]);
+      expect(p1).not.toBe(p2);
+    });
+  });
+});