@event-driven-io/emmett-sqlite 0.39.1 → 0.40.0

package/dist/index.cjs

@@ -103,6 +103,10 @@ var rollbackTransaction = (db) => new Promise((resolve, reject) => {
 var isNumber = (val) => typeof val === "number" && val === val;
 var isBigint = (val) => typeof val === "bigint" && 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 = class _EmmettError extends Error {
   static __initStatic() {this.Codes = {
     ValidationError: 400,
@@ -169,6 +173,207 @@ var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends C
     Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
+var isPrimitive = (value) => {
+  const type = typeof value;
+  return value === null || value === void 0 || type === "boolean" || type === "number" || type === "string" || type === "symbol" || type === "bigint";
+};
+var compareArrays = (left, right) => {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let i = 0; i < left.length; i++) {
+    const leftHas = i in left;
+    const rightHas = i in right;
+    if (leftHas !== rightHas) return false;
+    if (leftHas && !deepEquals(left[i], right[i])) return false;
+  }
+  return true;
+};
+var compareDates = (left, right) => {
+  return left.getTime() === right.getTime();
+};
+var compareRegExps = (left, right) => {
+  return left.toString() === right.toString();
+};
+var compareErrors = (left, right) => {
+  if (left.message !== right.message || left.name !== right.name) {
+    return false;
+  }
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) return false;
+  const rightKeySet = new Set(rightKeys);
+  for (const key of leftKeys) {
+    if (!rightKeySet.has(key)) return false;
+    if (!deepEquals(left[key], right[key])) return false;
+  }
+  return true;
+};
+var compareMaps = (left, right) => {
+  if (left.size !== right.size) return false;
+  for (const [key, value] of left) {
+    if (isPrimitive(key)) {
+      if (!right.has(key) || !deepEquals(value, right.get(key))) {
+        return false;
+      }
+    } else {
+      let found = false;
+      for (const [rightKey, rightValue] of right) {
+        if (deepEquals(key, rightKey) && deepEquals(value, rightValue)) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) return false;
+    }
+  }
+  return true;
+};
+var compareSets = (left, right) => {
+  if (left.size !== right.size) return false;
+  for (const leftItem of left) {
+    if (isPrimitive(leftItem)) {
+      if (!right.has(leftItem)) return false;
+    } else {
+      let found = false;
+      for (const rightItem of right) {
+        if (deepEquals(leftItem, rightItem)) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) return false;
+    }
+  }
+  return true;
+};
+var compareArrayBuffers = (left, right) => {
+  if (left.byteLength !== right.byteLength) return false;
+  const leftView = new Uint8Array(left);
+  const rightView = new Uint8Array(right);
+  for (let i = 0; i < leftView.length; i++) {
+    if (leftView[i] !== rightView[i]) return false;
+  }
+  return true;
+};
+var compareTypedArrays = (left, right) => {
+  if (left.constructor !== right.constructor) return false;
+  if (left.byteLength !== right.byteLength) return false;
+  const leftArray = new Uint8Array(
+    left.buffer,
+    left.byteOffset,
+    left.byteLength
+  );
+  const rightArray = new Uint8Array(
+    right.buffer,
+    right.byteOffset,
+    right.byteLength
+  );
+  for (let i = 0; i < leftArray.length; i++) {
+    if (leftArray[i] !== rightArray[i]) return false;
+  }
+  return true;
+};
+var compareObjects = (left, right) => {
+  const keys1 = Object.keys(left);
+  const keys2 = Object.keys(right);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (const key of keys1) {
+    if (left[key] instanceof Function && right[key] instanceof Function) {
+      continue;
+    }
+    const isEqual = deepEquals(left[key], right[key]);
+    if (!isEqual) {
+      return false;
+    }
+  }
+  return true;
+};
+var getType = (value) => {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const primitiveType = typeof value;
+  if (primitiveType !== "object") return primitiveType;
+  if (Array.isArray(value)) return "array";
+  if (value instanceof Boolean) return "boxed-boolean";
+  if (value instanceof Number) return "boxed-number";
+  if (value instanceof String) return "boxed-string";
+  if (value instanceof Date) return "date";
+  if (value instanceof RegExp) return "regexp";
+  if (value instanceof Error) return "error";
+  if (value instanceof Map) return "map";
+  if (value instanceof Set) return "set";
+  if (value instanceof ArrayBuffer) return "arraybuffer";
+  if (value instanceof DataView) return "dataview";
+  if (value instanceof WeakMap) return "weakmap";
+  if (value instanceof WeakSet) return "weakset";
+  if (ArrayBuffer.isView(value)) return "typedarray";
+  return "object";
+};
+var deepEquals = (left, right) => {
+  if (left === right) return true;
+  if (isEquatable(left)) {
+    return left.equals(right);
+  }
+  const leftType = getType(left);
+  const rightType = getType(right);
+  if (leftType !== rightType) return false;
+  switch (leftType) {
+    case "null":
+    case "undefined":
+    case "boolean":
+    case "number":
+    case "bigint":
+    case "string":
+    case "symbol":
+    case "function":
+      return left === right;
+    case "array":
+      return compareArrays(left, right);
+    case "date":
+      return compareDates(left, right);
+    case "regexp":
+      return compareRegExps(left, right);
+    case "error":
+      return compareErrors(left, right);
+    case "map":
+      return compareMaps(
+        left,
+        right
+      );
+    case "set":
+      return compareSets(left, right);
+    case "arraybuffer":
+      return compareArrayBuffers(left, right);
+    case "dataview":
+    case "weakmap":
+    case "weakset":
+      return false;
+    case "typedarray":
+      return compareTypedArrays(
+        left,
+        right
+      );
+    case "boxed-boolean":
+      return left.valueOf() === right.valueOf();
+    case "boxed-number":
+      return left.valueOf() === right.valueOf();
+    case "boxed-string":
+      return left.valueOf() === right.valueOf();
+    case "object":
+      return compareObjects(
+        left,
+        right
+      );
+    default:
+      return false;
+  }
+};
+var isEquatable = (left) => {
+  return left !== null && left !== void 0 && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
+};
 var ParseError = class extends Error {
   constructor(text) {
     super(`Cannot parse! ${text}`);
@@ -190,9 +395,110 @@ var JSONParser = {
     return _optionalChain([options, 'optionalAccess', _13 => _13.map]) ? options.map(parsed) : parsed;
   }
 };
+var AssertionError = class extends Error {
+  constructor(message2) {
+    super(message2);
+  }
+};
+var isSubset = (superObj, subObj) => {
+  const sup = superObj;
+  const sub = subObj;
+  assertOk(sup);
+  assertOk(sub);
+  return Object.keys(sub).every((ele) => {
+    if (typeof sub[ele] == "object") {
+      return isSubset(sup[ele], sub[ele]);
+    }
+    return sub[ele] === sup[ele];
+  });
+};
+var assertFails = (message2) => {
+  throw new AssertionError(_nullishCoalesce(message2, () => ( "That should not ever happened, right?")));
+};
+function assertTrue(condition, message2) {
+  if (condition !== true)
+    throw new AssertionError(_nullishCoalesce(message2, () => ( `Condition is false`)));
+}
+function assertOk(obj, message2) {
+  if (!obj) throw new AssertionError(_nullishCoalesce(message2, () => ( `Condition is not truthy`)));
+}
+function assertEqual(expected, actual, message2) {
+  if (expected !== actual)
+    throw new AssertionError(
+      `${_nullishCoalesce(message2, () => ( "Objects are not equal"))}:
+Expected: ${JSONParser.stringify(expected)}
+Actual: ${JSONParser.stringify(actual)}`
+    );
+}
+function assertNotEqual(obj, other, message2) {
+  if (obj === other)
+    throw new AssertionError(
+      _nullishCoalesce(message2, () => ( `Objects are equal: ${JSONParser.stringify(obj)}`))
+    );
+}
+var assertThatArray = (array) => {
+  return {
+    isEmpty: () => assertEqual(
+      array.length,
+      0,
+      `Array is not empty ${JSONParser.stringify(array)}`
+    ),
+    isNotEmpty: () => assertNotEqual(array.length, 0, `Array is empty`),
+    hasSize: (length) => assertEqual(array.length, length),
+    containsElements: (other) => {
+      assertTrue(other.every((ts) => array.some((o) => deepEquals(ts, o))));
+    },
+    containsElementsMatching: (other) => {
+      assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
+    },
+    containsOnlyElementsMatching: (other) => {
+      assertEqual(array.length, other.length, `Arrays lengths don't match`);
+      assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
+    },
+    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));
+      }
+    }
+  };
+};
 var getCheckpoint = (message2) => {
-  return "checkpoint" in message2.metadata && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  isBigint(message2.metadata.checkpoint) ? (
+  return "checkpoint" in message2.metadata ? (
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     message2.metadata.checkpoint
   ) : "globalPosition" in message2.metadata && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -205,8 +511,42 @@ var getCheckpoint = (message2) => {
     message2.metadata.streamPosition
   ) : null;
 };
+var projection = (definition) => definition;
 
-// src/eventStore/schema/appendToStream.ts
+// src/eventStore/projections/sqliteProjection.ts
+var handleProjections = async (options) => {
+  const { projections: allProjections, events, connection } = options;
+  const eventTypes = events.map((e) => e.type);
+  for (const projection2 of allProjections) {
+    if (!projection2.canHandle.some((type) => eventTypes.includes(type))) {
+      continue;
+    }
+    await projection2.handle(events, {
+      connection
+    });
+  }
+};
+var sqliteProjection = (definition) => projection(definition);
+var sqliteRawBatchSQLProjection = (handle, ...canHandle) => sqliteProjection({
+  canHandle,
+  handle: async (events, context) => {
+    const sqls = await handle(events, context);
+    for (const sql2 of sqls) await context.connection.command(sql2);
+  }
+});
+var sqliteRawSQLProjection = (handle, ...canHandle) => sqliteRawBatchSQLProjection(
+  async (events, context) => {
+    const sqls = [];
+    for (const event of events) {
+      sqls.push(await handle(event, context));
+    }
+    return sqls;
+  },
+  ...canHandle
+);
+
+// src/eventStore/projections/sqliteProjectionSpec.ts
+require('@event-driven-io/dumbo');
 
 
 // src/eventStore/schema/typing.ts
@@ -240,11 +580,200 @@ var subscriptionsTable = {
   name: `${emmettPrefix}_subscriptions`
 };
 
+// src/eventStore/schema/tables.ts
+var sql = (sql2) => sql2;
+var streamsTableSQL = sql(
+  `CREATE TABLE IF NOT EXISTS ${streamsTable.name}(
+      stream_id         TEXT                      NOT NULL,
+      stream_position   BIGINT                    NOT NULL DEFAULT 0,
+      partition         TEXT                      NOT NULL DEFAULT '${globalTag}',
+      stream_type       TEXT                      NOT NULL,
+      stream_metadata   JSONB                     NOT NULL,
+      is_archived       BOOLEAN                   NOT NULL DEFAULT FALSE,
+      PRIMARY KEY (stream_id, partition, is_archived),
+      UNIQUE (stream_id, partition, is_archived)
+  );`
+);
+var messagesTableSQL = sql(
+  `CREATE TABLE IF NOT EXISTS ${messagesTable.name}(
+      stream_id              TEXT                      NOT NULL,
+      stream_position        BIGINT                    NOT NULL,
+      partition              TEXT                      NOT NULL DEFAULT '${globalTag}',
+      message_kind           CHAR(1)                   NOT NULL DEFAULT 'E',
+      message_data           JSONB                     NOT NULL,
+      message_metadata       JSONB                     NOT NULL,
+      message_schema_version TEXT                      NOT NULL,
+      message_type           TEXT                      NOT NULL,
+      message_id             TEXT                      NOT NULL,
+      is_archived            BOOLEAN                   NOT NULL DEFAULT FALSE,
+      global_position        INTEGER                   PRIMARY KEY,
+      created                DATETIME                  DEFAULT CURRENT_TIMESTAMP,
+      UNIQUE (stream_id, stream_position, partition, is_archived)
+  ); 
+`
+);
+var subscriptionsTableSQL = sql(
+  `
+  CREATE TABLE IF NOT EXISTS ${subscriptionsTable.name}(
+      subscription_id                 TEXT                   NOT NULL,
+      version                         INTEGER                NOT NULL DEFAULT 1,
+      partition                       TEXT                   NOT NULL DEFAULT '${globalTag}',
+      last_processed_position         BIGINT                NOT NULL,
+      PRIMARY KEY (subscription_id, partition, version)
+  );
+`
+);
+var schemaSQL = [
+  streamsTableSQL,
+  messagesTableSQL,
+  subscriptionsTableSQL
+];
+var createEventStoreSchema = async (db) => {
+  for (const sql2 of schemaSQL) {
+    await db.command(sql2);
+  }
+};
+
+// src/eventStore/schema/utils.ts
+var singleOrNull = async (getResult) => {
+  const result = await getResult;
+  if (result.length > 1) throw new Error("Query had more than one result");
+  return result.length > 0 ? _nullishCoalesce(result[0], () => ( null)) : null;
+};
+
+// src/eventStore/schema/readLastMessageGlobalPosition.ts
+var readLastMessageGlobalPosition = async (db, options) => {
+  const result = await singleOrNull(
+    db.query(
+      sql(
+        `SELECT global_position
+         FROM ${messagesTable.name}
+         WHERE partition = ? AND is_archived = FALSE
+         ORDER BY global_position
+         LIMIT 1`
+      ),
+      [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _14 => _14.partition]), () => ( defaultTag))]
+    )
+  );
+  return {
+    currentGlobalPosition: result !== null ? BigInt(result.global_position) : null
+  };
+};
+
+// src/eventStore/schema/readMessagesBatch.ts
+var readMessagesBatch = async (db, options) => {
+  const from = "from" in options ? options.from : "after" in options ? options.after + 1n : 0n;
+  const batchSize = options && "batchSize" in options ? options.batchSize : options.to - options.from;
+  const fromCondition = from !== -0n ? `AND global_position >= ${from}` : "";
+  const toCondition = "to" in options ? `AND global_position <= ${options.to}` : "";
+  const limitCondition = "batchSize" in options ? `LIMIT ${options.batchSize}` : "";
+  const events = (await db.query(
+    sql(
+      `SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
+           FROM ${messagesTable.name}
+           WHERE partition = ? AND is_archived = FALSE ${fromCondition} ${toCondition}
+           ORDER BY global_position
+           ${limitCondition}`
+    ),
+    [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _15 => _15.partition]), () => ( defaultTag))]
+  )).map((row) => {
+    const rawEvent = {
+      type: row.message_type,
+      data: JSONParser.parse(row.message_data),
+      metadata: JSONParser.parse(row.message_metadata)
+    };
+    const metadata = {
+      ..."metadata" in rawEvent ? _nullishCoalesce(rawEvent.metadata, () => ( {})) : {},
+      messageId: row.message_id,
+      streamName: row.stream_id,
+      streamPosition: BigInt(row.stream_position),
+      globalPosition: BigInt(row.global_position)
+    };
+    return {
+      ...rawEvent,
+      kind: "Event",
+      metadata
+    };
+  });
+  return events.length > 0 ? {
+    currentGlobalPosition: events[events.length - 1].metadata.globalPosition,
+    messages: events,
+    areEventsLeft: events.length === batchSize
+  } : {
+    currentGlobalPosition: "from" in options ? options.from : "after" in options ? options.after : 0n,
+    messages: [],
+    areEventsLeft: false
+  };
+};
+
+// src/eventStore/consumers/messageBatchProcessing/index.ts
+var DefaultSQLiteEventStoreProcessorBatchSize = 100;
+var DefaultSQLiteEventStoreProcessorPullingFrequencyInMs = 50;
+var sqliteEventStoreMessageBatchPuller = ({
+  connection,
+  batchSize,
+  eachBatch,
+  pullingFrequencyInMs
+}) => {
+  let isRunning = false;
+  let start;
+  const pullMessages = async (options) => {
+    const after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? await _asyncNullishCoalesce((await readLastMessageGlobalPosition(connection)).currentGlobalPosition, async () => ( 0n)) : options.startFrom.globalPosition;
+    const readMessagesOptions = {
+      after,
+      batchSize
+    };
+    let waitTime = 100;
+    do {
+      const { messages, currentGlobalPosition, areEventsLeft } = await readMessagesBatch(connection, readMessagesOptions);
+      if (messages.length > 0) {
+        const result = await eachBatch({ messages });
+        if (result && result.type === "STOP") {
+          isRunning = false;
+          break;
+        }
+      }
+      readMessagesOptions.after = currentGlobalPosition;
+      await new Promise((resolve) => setTimeout(resolve, waitTime));
+      if (!areEventsLeft) {
+        waitTime = Math.min(waitTime * 2, 1e3);
+      } else {
+        waitTime = pullingFrequencyInMs;
+      }
+    } while (isRunning);
+  };
+  return {
+    get isRunning() {
+      return isRunning;
+    },
+    start: (options) => {
+      if (isRunning) return start;
+      start = (async () => {
+        isRunning = true;
+        return pullMessages(options);
+      })();
+      return start;
+    },
+    stop: async () => {
+      if (!isRunning) return;
+      isRunning = false;
+      await start;
+    }
+  };
+};
+var zipSQLiteEventStoreMessageBatchPullerStartFrom = (options) => {
+  if (options.length === 0 || options.some((o) => o === void 0 || o === "BEGINNING"))
+    return "BEGINNING";
+  if (options.every((o) => o === "END")) return "END";
+  return options.filter((o) => o !== void 0 && o !== "BEGINNING" && o !== "END").sort((a, b) => a > b ? 1 : -1)[0];
+};
+
 // src/eventStore/schema/appendToStream.ts
+
 var appendToStream = async (connection, streamName, streamType, messages, options) => {
   if (messages.length === 0) return { success: false };
   const expectedStreamVersion = toExpectedVersion(
-    _optionalChain([options, 'optionalAccess', _14 => _14.expectedStreamVersion])
+    _optionalChain([options, 'optionalAccess', _16 => _16.expectedStreamVersion])
   );
   const messagesToAppend = messages.map(
     (m, i) => ({
@@ -269,7 +798,7 @@ var appendToStream = async (connection, streamName, streamType, messages, option
         expectedStreamVersion
       }
     );
-    if (_optionalChain([options, 'optionalAccess', _15 => _15.onBeforeCommit]))
+    if (_optionalChain([options, 'optionalAccess', _17 => _17.onBeforeCommit]))
       await options.onBeforeCommit(messagesToAppend, { connection });
     return result;
   });
@@ -285,7 +814,7 @@ var appendToStreamRaw = async (connection, streamId, streamType, messages, optio
   let streamPosition;
   let globalPosition;
   try {
-    let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _16 => _16.expectedStreamVersion]), () => ( null));
+    let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _18 => _18.expectedStreamVersion]), () => ( null));
     if (expectedStreamVersion == null) {
       expectedStreamVersion = await getLastStreamPosition(
         connection,
@@ -311,7 +840,7 @@ var appendToStreamRaw = async (connection, streamId, streamType, messages, optio
         [
           streamId,
           messages.length,
-          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _17 => _17.partition]), () => ( streamsTable.columns.partition)),
+          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _19 => _19.partition]), () => ( streamsTable.columns.partition)),
           streamType
         ]
       );
@@ -327,7 +856,7 @@ var appendToStreamRaw = async (connection, streamId, streamType, messages, optio
         [
           messages.length,
           streamId,
-          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _18 => _18.partition]), () => ( streamsTable.columns.partition))
+          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _20 => _20.partition]), () => ( streamsTable.columns.partition))
         ]
       );
     }
@@ -347,10 +876,10 @@ var appendToStreamRaw = async (connection, streamId, streamType, messages, optio
       messages,
       expectedStreamVersion,
       streamId,
-      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _19 => _19.partition, 'optionalAccess', _20 => _20.toString, 'call', _21 => _21()]), () => ( defaultTag))
+      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _21 => _21.partition, 'optionalAccess', _22 => _22.toString, 'call', _23 => _23()]), () => ( defaultTag))
     );
     const returningIds = await connection.query(sqlString, values);
-    if (returningIds.length === 0 || !_optionalChain([returningIds, 'access', _22 => _22[returningIds.length - 1], 'optionalAccess', _23 => _23.global_position])) {
+    if (returningIds.length === 0 || !_optionalChain([returningIds, 'access', _24 => _24[returningIds.length - 1], 'optionalAccess', _25 => _25.global_position])) {
       throw new Error("Could not find global position");
     }
     globalPosition = BigInt(
@@ -371,14 +900,14 @@ var appendToStreamRaw = async (connection, streamId, streamType, messages, optio
   };
 };
 var isOptimisticConcurrencyError = (error) => {
-  return _optionalChain([error, 'optionalAccess', _24 => _24.errno]) !== void 0 && error.errno === 19;
+  return _optionalChain([error, 'optionalAccess', _26 => _26.errno]) !== void 0 && error.errno === 19;
 };
 async function getLastStreamPosition(connection, streamId, expectedStreamVersion) {
   const result = await connection.querySingle(
     `SELECT CAST(stream_position AS VARCHAR) AS stream_position FROM ${streamsTable.name} WHERE stream_id = ?`,
     [streamId]
   );
-  if (_optionalChain([result, 'optionalAccess', _25 => _25.stream_position]) == null) {
+  if (_optionalChain([result, 'optionalAccess', _27 => _27.stream_position]) == null) {
     expectedStreamVersion = 0n;
   } else {
     expectedStreamVersion = BigInt(result.stream_position);
@@ -388,7 +917,7 @@ async function getLastStreamPosition(connection, streamId, expectedStreamVersion
 var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partition) => {
   const query = messages.reduce(
     (queryBuilder, message) => {
-      if (_optionalChain([message, 'access', _26 => _26.metadata, 'optionalAccess', _27 => _27.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
+      if (_optionalChain([message, 'access', _28 => _28.metadata, 'optionalAccess', _29 => _29.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
         throw new Error("Stream position is required");
       }
       const streamPosition = BigInt(message.metadata.streamPosition) + BigInt(expectedStreamVersion);
@@ -400,7 +929,7 @@ var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partit
         message.kind === "Event" ? "E" : "C",
         JSONParser.stringify(message.data),
         JSONParser.stringify(message.metadata),
-        _nullishCoalesce(_optionalChain([expectedStreamVersion, 'optionalAccess', _28 => _28.toString, 'call', _29 => _29()]), () => ( 0)),
+        _nullishCoalesce(_optionalChain([expectedStreamVersion, 'optionalAccess', _30 => _30.toString, 'call', _31 => _31()]), () => ( 0)),
         message.type,
         message.metadata.messageId,
         false
@@ -432,103 +961,39 @@ var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partit
   return { sqlString, values: query.values };
 };
 
-// src/eventStore/schema/tables.ts
-var sql = (sql2) => sql2;
-var streamsTableSQL = sql(
-  `CREATE TABLE IF NOT EXISTS ${streamsTable.name}(
-      stream_id         TEXT                      NOT NULL,
-      stream_position   BIGINT                    NOT NULL DEFAULT 0,
-      partition         TEXT                      NOT NULL DEFAULT '${globalTag}',
-      stream_type       TEXT                      NOT NULL,
-      stream_metadata   JSONB                     NOT NULL,
-      is_archived       BOOLEAN                   NOT NULL DEFAULT FALSE,
-      PRIMARY KEY (stream_id, partition, is_archived),
-      UNIQUE (stream_id, partition, is_archived)
-  );`
-);
-var messagesTableSQL = sql(
-  `CREATE TABLE IF NOT EXISTS ${messagesTable.name}(
-      stream_id              TEXT                      NOT NULL,
-      stream_position        BIGINT                    NOT NULL,
-      partition              TEXT                      NOT NULL DEFAULT '${globalTag}',
-      message_kind           CHAR(1)                   NOT NULL DEFAULT 'E',
-      message_data           JSONB                     NOT NULL,
-      message_metadata       JSONB                     NOT NULL,
-      message_schema_version TEXT                      NOT NULL,
-      message_type           TEXT                      NOT NULL,
-      message_id             TEXT                      NOT NULL,
-      is_archived            BOOLEAN                   NOT NULL DEFAULT FALSE,
-      global_position        INTEGER                   PRIMARY KEY,
-      created                DATETIME                  DEFAULT CURRENT_TIMESTAMP,
-      UNIQUE (stream_id, stream_position, partition, is_archived)
-  ); 
-`
-);
-var subscriptionsTableSQL = sql(
-  `
-  CREATE TABLE IF NOT EXISTS ${subscriptionsTable.name}(
-      subscription_id                 TEXT                   NOT NULL,
-      version                         INTEGER                NOT NULL DEFAULT 1,
-      partition                       TEXT                   NOT NULL DEFAULT '${globalTag}',
-      last_processed_position         BIGINT                NOT NULL,
-      PRIMARY KEY (subscription_id, partition, version)
-  );
-`
-);
-var schemaSQL = [
-  streamsTableSQL,
-  messagesTableSQL,
-  subscriptionsTableSQL
-];
-var createEventStoreSchema = async (db) => {
-  for (const sql2 of schemaSQL) {
-    await db.command(sql2);
-  }
-};
-
-// src/eventStore/schema/utils.ts
-var singleOrNull = async (getResult) => {
-  const result = await getResult;
-  if (result.length > 1) throw new Error("Query had more than one result");
-  return result.length > 0 ? _nullishCoalesce(result[0], () => ( null)) : null;
-};
-
-// src/eventStore/schema/readLastMessageGlobalPosition.ts
-var readLastMessageGlobalPosition = async (db, options) => {
+// src/eventStore/schema/readProcessorCheckpoint.ts
+var readProcessorCheckpoint = async (db, options) => {
   const result = await singleOrNull(
     db.query(
       sql(
-        `SELECT global_position
-         FROM ${messagesTable.name}
-         WHERE partition = ? AND is_archived = FALSE
-         ORDER BY global_position
-         LIMIT 1`
+        `SELECT last_processed_position
+           FROM ${subscriptionsTable.name}
+           WHERE partition = ? AND subscription_id = ?
+           LIMIT 1`
       ),
-      [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _30 => _30.partition]), () => ( defaultTag))]
+      [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _32 => _32.partition]), () => ( defaultTag)), options.processorId]
     )
   );
   return {
-    currentGlobalPosition: result !== null ? BigInt(result.global_position) : null
+    lastProcessedPosition: result !== null ? BigInt(result.last_processed_position) : null
   };
 };
 
-// src/eventStore/schema/readMessagesBatch.ts
-var readMessagesBatch = async (db, options) => {
-  const from = "from" in options ? options.from : "after" in options ? options.after + 1n : 0n;
-  const batchSize = options && "batchSize" in options ? options.batchSize : options.to - options.from;
-  const fromCondition = from !== -0n ? `AND global_position >= ${from}` : "";
-  const toCondition = "to" in options ? `AND global_position <= ${options.to}` : "";
-  const limitCondition = "batchSize" in options ? `LIMIT ${options.batchSize}` : "";
-  const events = (await db.query(
-    sql(
-      `SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
+// src/eventStore/schema/readStream.ts
+var readStream = async (db, 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 results = await db.query(
+    `SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
            FROM ${messagesTable.name}
-           WHERE partition = ? AND is_archived = FALSE ${fromCondition} ${toCondition}
-           ORDER BY global_position
-           ${limitCondition}`
-    ),
-    [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _31 => _31.partition]), () => ( defaultTag))]
-  )).map((row) => {
+           WHERE stream_id = ? AND partition = ? AND is_archived = FALSE ${fromCondition} ${toCondition}
+           ORDER BY stream_position ASC`,
+    [streamId, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _33 => _33.partition]), () => ( defaultTag))]
+  );
+  const messages = results.map((row) => {
     const rawEvent = {
       type: row.message_type,
       data: JSONParser.parse(row.message_data),
@@ -537,7 +1002,7 @@ var readMessagesBatch = async (db, options) => {
     const metadata = {
       ..."metadata" in rawEvent ? _nullishCoalesce(rawEvent.metadata, () => ( {})) : {},
       messageId: row.message_id,
-      streamName: row.stream_id,
+      streamName: streamId,
       streamPosition: BigInt(row.stream_position),
       globalPosition: BigInt(row.global_position)
     };
@@ -547,108 +1012,107 @@ var readMessagesBatch = async (db, options) => {
       metadata
     };
   });
-  return events.length > 0 ? {
-    currentGlobalPosition: events[events.length - 1].metadata.globalPosition,
-    messages: events,
-    areEventsLeft: events.length === batchSize
+  return messages.length > 0 ? {
+    currentStreamVersion: messages[messages.length - 1].metadata.streamPosition,
+    events: messages,
+    streamExists: true
   } : {
-    currentGlobalPosition: "from" in options ? options.from : "after" in options ? options.after : 0n,
-    messages: [],
-    areEventsLeft: false
-  };
-};
-
-// src/eventStore/schema/readProcessorCheckpoint.ts
-var readProcessorCheckpoint = async (db, options) => {
-  const result = await singleOrNull(
-    db.query(
-      sql(
-        `SELECT last_processed_position
-           FROM ${subscriptionsTable.name}
-           WHERE partition = ? AND subscription_id = ?
-           LIMIT 1`
-      ),
-      [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _32 => _32.partition]), () => ( defaultTag)), options.processorId]
-    )
-  );
-  return {
-    lastProcessedPosition: result !== null ? BigInt(result.last_processed_position) : null
-  };
-};
-
-// src/eventStore/consumers/messageBatchProcessing/index.ts
-var DefaultSQLiteEventStoreProcessorBatchSize = 100;
-var DefaultSQLiteEventStoreProcessorPullingFrequencyInMs = 50;
-var sqliteEventStoreMessageBatchPuller = ({
-  connection,
-  batchSize,
-  eachBatch,
-  pullingFrequencyInMs
-}) => {
-  let isRunning = false;
-  let start;
-  const pullMessages = async (options) => {
-    const after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? await _asyncNullishCoalesce((await readLastMessageGlobalPosition(connection)).currentGlobalPosition, async () => ( 0n)) : options.startFrom.globalPosition;
-    const readMessagesOptions = {
-      after,
-      batchSize
-    };
-    let waitTime = 100;
-    do {
-      const { messages, currentGlobalPosition, areEventsLeft } = await readMessagesBatch(connection, readMessagesOptions);
-      if (messages.length > 0) {
-        const result = await eachBatch({ messages });
-        if (result && result.type === "STOP") {
-          isRunning = false;
-          break;
-        }
+    currentStreamVersion: SQLiteEventStoreDefaultStreamVersion,
+    events: [],
+    streamExists: false
+  };
+};
+
+// src/eventStore/schema/storeProcessorCheckpoint.ts
+async function storeSubscriptionCheckpointSQLite(db, processorId, version, position, checkPosition, partition) {
+  if (checkPosition !== null) {
+    const updateResult = await db.command(
+      sql(`
+          UPDATE ${subscriptionsTable.name}
+          SET last_processed_position = ?
+          WHERE subscription_id = ? 
+            AND last_processed_position = ? 
+            AND partition = ?
+        `),
+      [position.toString(), processorId, checkPosition.toString(), partition]
+    );
+    if (updateResult.changes > 0) {
+      return 1;
+    } else {
+      const current_position = await singleOrNull(
+        db.query(
+          sql(
+            `SELECT last_processed_position FROM ${subscriptionsTable.name} 
+               WHERE subscription_id = ? AND partition = ?`
+          ),
+          [processorId, partition]
+        )
+      );
+      if (_optionalChain([current_position, 'optionalAccess', _34 => _34.last_processed_position]) === position) {
+        return 0;
+      } else if (position !== null && current_position !== null && _optionalChain([current_position, 'optionalAccess', _35 => _35.last_processed_position]) > position) {
+        return 2;
+      } else {
+        return 2;
       }
-      readMessagesOptions.after = currentGlobalPosition;
-      await new Promise((resolve) => setTimeout(resolve, waitTime));
-      if (!areEventsLeft) {
-        waitTime = Math.min(waitTime * 2, 1e3);
+    }
+  } else {
+    try {
+      await db.command(
+        sql(
+          `INSERT INTO ${subscriptionsTable.name} (subscription_id, version, last_processed_position, partition) VALUES (?, ?, ?, ?)`
+        ),
+        [processorId, version, position.toString(), partition]
+      );
+      return 1;
+    } catch (err) {
+      if (!(isSQLiteError(err) && (err.errno === 19 || err.errno === 2067))) {
+        throw err;
+      }
+      const current = await singleOrNull(
+        db.query(
+          sql(
+            `SELECT last_processed_position FROM ${subscriptionsTable.name} WHERE subscription_id = ? AND partition = ?`
+          ),
+          [processorId, partition]
+        )
+      );
+      if (_optionalChain([current, 'optionalAccess', _36 => _36.last_processed_position]) === position) {
+        return 0;
       } else {
-        waitTime = pullingFrequencyInMs;
+        return 2;
       }
-    } while (isRunning);
-  };
-  return {
-    get isRunning() {
-      return isRunning;
-    },
-    start: (options) => {
-      if (isRunning) return start;
-      start = (async () => {
-        isRunning = true;
-        return pullMessages(options);
-      })();
-      return start;
-    },
-    stop: async () => {
-      if (!isRunning) return;
-      isRunning = false;
-      await start;
     }
-  };
-};
-var zipSQLiteEventStoreMessageBatchPullerStartFrom = (options) => {
-  if (options.length === 0 || options.some((o) => o === void 0 || o === "BEGINNING"))
-    return "BEGINNING";
-  if (options.every((o) => o === "END")) return "END";
-  return options.filter((o) => o !== void 0 && o !== "BEGINNING" && o !== "END").sort((a, b) => a > b ? 1 : -1)[0];
-};
+  }
+}
+async function storeProcessorCheckpoint(db, options) {
+  try {
+    const result = await storeSubscriptionCheckpointSQLite(
+      db,
+      options.processorId,
+      _nullishCoalesce(options.version, () => ( 1)),
+      options.newPosition,
+      options.lastProcessedPosition,
+      _nullishCoalesce(options.partition, () => ( defaultTag))
+    );
+    return result === 1 ? { success: true, newPosition: options.newPosition } : { success: false, reason: result === 0 ? "IGNORED" : "MISMATCH" };
+  } catch (error) {
+    console.log(error);
+    throw error;
+  }
+}
 
 // src/eventStore/consumers/sqliteProcessor.ts
 var genericSQLiteProcessor = (options) => {
   const { eachMessage } = options;
   let isActive = true;
   const getDb = (context) => {
-    const fileName = _nullishCoalesce(context.fileName, () => ( _optionalChain([options, 'access', _33 => _33.connectionOptions, 'optionalAccess', _34 => _34.fileName])));
+    const fileName = _nullishCoalesce(context.fileName, () => ( _optionalChain([options, 'access', _37 => _37.connectionOptions, 'optionalAccess', _38 => _38.fileName])));
     if (!fileName)
       throw new EmmettError(
         `SQLite processor '${options.processorId}' is missing file name. Ensure that you passed it through options`
       );
-    const connection = _nullishCoalesce(_nullishCoalesce(context.connection, () => ( _optionalChain([options, 'access', _35 => _35.connectionOptions, 'optionalAccess', _36 => _36.connection]))), () => ( sqliteConnection({ fileName })));
+    const connection = _nullishCoalesce(_nullishCoalesce(context.connection, () => ( _optionalChain([options, 'access', _39 => _39.connectionOptions, 'optionalAccess', _40 => _40.connection]))), () => ( sqliteConnection({ fileName })));
     return { connection, fileName };
   };
   return {
@@ -750,7 +1214,7 @@ var sqliteEventStoreConsumer = (options) => {
       })
     );
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _37 => _37.value, 'optionalAccess', _38 => _38.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _41 => _41.value, 'optionalAccess', _42 => _42.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
@@ -758,8 +1222,8 @@ var sqliteEventStoreConsumer = (options) => {
   const messagePooler = currentMessagePuller = sqliteEventStoreMessageBatchPuller({
     connection,
     eachBatch,
-    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _39 => _39.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
-    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _40 => _40.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs))
+    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _43 => _43.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
+    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _44 => _44.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs))
   });
   const stop = async () => {
     if (!isRunning) return;
@@ -806,20 +1270,6 @@ var sqliteEventStoreConsumer = (options) => {
   };
 };
 
-// src/eventStore/projections/index.ts
-var handleProjections = async (options) => {
-  const { projections: allProjections, events, connection } = options;
-  const eventTypes = events.map((e) => e.type);
-  for (const projection2 of allProjections) {
-    if (!projection2.canHandle.some((type) => eventTypes.includes(type))) {
-      continue;
-    }
-    await projection2.handle(events, {
-      connection
-    });
-  }
-};
-
 // src/eventStore/SQLiteEventStore.ts
 var SQLiteEventStoreDefaultStreamVersion = 0n;
 var getSQLiteEventStore = (options) => {
@@ -829,7 +1279,7 @@ var getSQLiteEventStore = (options) => {
   const fileName = _nullishCoalesce(options.fileName, () => ( InMemorySQLiteDatabase));
   const isInMemory = fileName === InMemorySQLiteDatabase || fileName === InMemorySharedCacheSQLiteDatabase;
   const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
-  const onBeforeCommitHook = _optionalChain([options, 'access', _41 => _41.hooks, 'optionalAccess', _42 => _42.onBeforeCommit]);
+  const onBeforeCommitHook = _optionalChain([options, 'access', _45 => _45.hooks, 'optionalAccess', _46 => _46.onBeforeCommit]);
   const createConnection = () => {
     if (database != null) {
       return database;
@@ -859,7 +1309,7 @@ var getSQLiteEventStore = (options) => {
     }
   };
   if (options) {
-    autoGenerateSchema = _optionalChain([options, 'access', _43 => _43.schema, 'optionalAccess', _44 => _44.autoMigration]) === void 0 || _optionalChain([options, 'access', _45 => _45.schema, 'optionalAccess', _46 => _46.autoMigration]) !== "None";
+    autoGenerateSchema = _optionalChain([options, 'access', _47 => _47.schema, 'optionalAccess', _48 => _48.autoMigration]) === void 0 || _optionalChain([options, 'access', _49 => _49.schema, 'optionalAccess', _50 => _50.autoMigration]) !== "None";
   }
   const ensureSchemaExists = async (connection) => {
     if (!autoGenerateSchema) return Promise.resolve();
@@ -872,7 +1322,7 @@ var getSQLiteEventStore = (options) => {
   return {
     async aggregateStream(streamName, options2) {
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _47 => _47.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _51 => _51.expectedStreamVersion]);
       let state = initialState();
       if (typeof streamName !== "string") {
         throw new Error("Stream name is not string");
@@ -926,7 +1376,7 @@ var getSQLiteEventStore = (options) => {
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _48 => _48.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _52 => _52.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
@@ -942,128 +1392,130 @@ var getSQLiteEventStore = (options) => {
   };
 };
 
-// src/eventStore/schema/readStream.ts
-var readStream = async (db, 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 results = await db.query(
-    `SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
-           FROM ${messagesTable.name}
-           WHERE stream_id = ? AND partition = ? AND is_archived = FALSE ${fromCondition} ${toCondition}
-           ORDER BY stream_position ASC`,
-    [streamId, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _49 => _49.partition]), () => ( defaultTag))]
-  );
-  const messages = results.map((row) => {
-    const rawEvent = {
-      type: row.message_type,
-      data: JSONParser.parse(row.message_data),
-      metadata: JSONParser.parse(row.message_metadata)
-    };
-    const metadata = {
-      ..."metadata" in rawEvent ? _nullishCoalesce(rawEvent.metadata, () => ( {})) : {},
-      messageId: row.message_id,
-      streamName: streamId,
-      streamPosition: BigInt(row.stream_position),
-      globalPosition: BigInt(row.global_position)
-    };
-    return {
-      ...rawEvent,
-      kind: "Event",
-      metadata
-    };
-  });
-  return messages.length > 0 ? {
-    currentStreamVersion: messages[messages.length - 1].metadata.streamPosition,
-    events: messages,
-    streamExists: true
-  } : {
-    currentStreamVersion: SQLiteEventStoreDefaultStreamVersion,
-    events: [],
-    streamExists: false
-  };
+// src/eventStore/projections/sqliteProjectionSpec.ts
+var SQLiteProjectionSpec = {
+  for: (options) => {
+    {
+      const connection = options.connection;
+      const projection2 = options.projection;
+      return (givenEvents) => {
+        return {
+          when: (events, options2) => {
+            const allEvents = [];
+            const run = async (connection2) => {
+              let globalPosition = 0n;
+              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _53 => _53.numberOfTimes]), () => ( 1));
+              for (const event of [
+                ...givenEvents,
+                ...Array.from({ length: numberOfTimes }).flatMap(() => events)
+              ]) {
+                const metadata = {
+                  globalPosition: ++globalPosition,
+                  streamPosition: globalPosition,
+                  streamName: `test-${_uuid.v4.call(void 0, )}`,
+                  messageId: _uuid.v4.call(void 0, )
+                };
+                allEvents.push({
+                  ...event,
+                  kind: "Event",
+                  metadata: {
+                    ...metadata,
+                    ..."metadata" in event ? _nullishCoalesce(event.metadata, () => ( {})) : {}
+                  }
+                });
+              }
+              await connection2.withTransaction(
+                () => handleProjections({
+                  events: allEvents,
+                  projections: [projection2],
+                  connection: connection2
+                })
+              );
+            };
+            return {
+              then: async (assert, message) => {
+                try {
+                  await run(connection);
+                  const succeeded = await assert({
+                    connection
+                  });
+                  if (succeeded !== void 0 && succeeded === false)
+                    assertFails(
+                      _nullishCoalesce(message, () => ( "Projection specification didn't match the criteria"))
+                    );
+                } finally {
+                  connection.close();
+                }
+              },
+              thenThrows: async (...args) => {
+                try {
+                  await run(connection);
+                  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', _54 => _54.toString, 'call', _55 => _55()])}`
+                    );
+                    return;
+                  }
+                  assertTrue(
+                    error instanceof args[0],
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _56 => _56.toString, 'call', _57 => _57()])}`
+                  );
+                  if (args[1]) {
+                    assertTrue(
+                      args[1](error),
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _58 => _58.toString, 'call', _59 => _59()])}`
+                    );
+                  }
+                } finally {
+                  connection.close();
+                }
+              }
+            };
+          }
+        };
+      };
+    }
+  }
 };
-
-// src/eventStore/schema/storeProcessorCheckpoint.ts
-async function storeSubscriptionCheckpointSQLite(db, processorId, version, position, checkPosition, partition) {
-  if (checkPosition !== null) {
-    const updateResult = await db.command(
-      sql(`
-          UPDATE ${subscriptionsTable.name}
-          SET last_processed_position = ?
-          WHERE subscription_id = ? 
-            AND last_processed_position = ? 
-            AND partition = ?
-        `),
-      [position.toString(), processorId, checkPosition.toString(), partition]
-    );
-    if (updateResult.changes > 0) {
-      return 1;
-    } else {
-      const current_position = await singleOrNull(
-        db.query(
-          sql(
-            `SELECT last_processed_position FROM ${subscriptionsTable.name} 
-               WHERE subscription_id = ? AND partition = ?`
-          ),
-          [processorId, partition]
-        )
-      );
-      if (_optionalChain([current_position, 'optionalAccess', _50 => _50.last_processed_position]) === position) {
-        return 0;
-      } else if (position !== null && current_position !== null && _optionalChain([current_position, 'optionalAccess', _51 => _51.last_processed_position]) > position) {
-        return 2;
-      } else {
-        return 2;
-      }
+var eventInStream = (streamName, event) => {
+  return {
+    ...event,
+    metadata: {
+      ..._nullishCoalesce(event.metadata, () => ( {})),
+      streamName: _nullishCoalesce(_optionalChain([event, 'access', _60 => _60.metadata, 'optionalAccess', _61 => _61.streamName]), () => ( streamName))
     }
-  } else {
-    try {
-      await db.command(
-        sql(
-          `INSERT INTO ${subscriptionsTable.name} (subscription_id, version, last_processed_position, partition) VALUES (?, ?, ?, ?)`
-        ),
-        [processorId, version, position.toString(), partition]
-      );
-      return 1;
-    } catch (err) {
-      if (!(isSQLiteError(err) && (err.errno === 19 || err.errno === 2067))) {
-        throw err;
-      }
-      const current = await singleOrNull(
-        db.query(
-          sql(
-            `SELECT last_processed_position FROM ${subscriptionsTable.name} WHERE subscription_id = ? AND partition = ?`
-          ),
-          [processorId, partition]
-        )
-      );
-      if (_optionalChain([current, 'optionalAccess', _52 => _52.last_processed_position]) === position) {
-        return 0;
-      } else {
-        return 2;
-      }
+  };
+};
+var eventsInStream = (streamName, events) => {
+  return events.map((e) => eventInStream(streamName, e));
+};
+var newEventsInStream = eventsInStream;
+var assertSQLQueryResultMatches = (sql2, rows) => async ({ connection }) => {
+  const result = await connection.query(sql2);
+  assertThatArray(rows).containsExactlyInAnyOrder(result);
+};
+var expectSQL = {
+  query: (sql2) => ({
+    resultRows: {
+      toBeTheSame: (rows) => assertSQLQueryResultMatches(sql2, rows)
     }
-  }
-}
-async function storeProcessorCheckpoint(db, options) {
-  try {
-    const result = await storeSubscriptionCheckpointSQLite(
-      db,
-      options.processorId,
-      _nullishCoalesce(options.version, () => ( 1)),
-      options.newPosition,
-      options.lastProcessedPosition,
-      _nullishCoalesce(options.partition, () => ( defaultTag))
-    );
-    return result === 1 ? { success: true, newPosition: options.newPosition } : { success: false, reason: result === 0 ? "IGNORED" : "MISMATCH" };
-  } catch (error) {
-    console.log(error);
-    throw error;
-  }
-}
+  })
+};
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -1090,5 +1542,5 @@ async function storeProcessorCheckpoint(db, options) {
 
 
 
-exports.InMemorySQLiteDatabase = InMemorySQLiteDatabase; exports.InMemorySharedCacheSQLiteDatabase = InMemorySharedCacheSQLiteDatabase; exports.SQLiteEventStoreDefaultStreamVersion = SQLiteEventStoreDefaultStreamVersion; exports.appendToStream = appendToStream; exports.createEventStoreSchema = createEventStoreSchema; exports.defaultTag = defaultTag; exports.emmettPrefix = emmettPrefix; exports.getSQLiteEventStore = getSQLiteEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.isSQLiteError = isSQLiteError; exports.messagesTable = messagesTable; exports.messagesTableSQL = messagesTableSQL; exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition; exports.readMessagesBatch = readMessagesBatch; exports.readProcessorCheckpoint = readProcessorCheckpoint; exports.readStream = readStream; exports.schemaSQL = schemaSQL; exports.sql = sql; exports.sqliteConnection = sqliteConnection; exports.storeProcessorCheckpoint = storeProcessorCheckpoint; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.subscriptionsTable = subscriptionsTable; exports.subscriptionsTableSQL = subscriptionsTableSQL;
+exports.InMemorySQLiteDatabase = InMemorySQLiteDatabase; exports.InMemorySharedCacheSQLiteDatabase = InMemorySharedCacheSQLiteDatabase; exports.SQLiteEventStoreDefaultStreamVersion = SQLiteEventStoreDefaultStreamVersion; exports.SQLiteProjectionSpec = SQLiteProjectionSpec; exports.appendToStream = appendToStream; exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches; exports.createEventStoreSchema = createEventStoreSchema; exports.defaultTag = defaultTag; exports.emmettPrefix = emmettPrefix; exports.eventInStream = eventInStream; exports.eventsInStream = eventsInStream; exports.expectSQL = expectSQL; exports.getSQLiteEventStore = getSQLiteEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.isSQLiteError = isSQLiteError; exports.messagesTable = messagesTable; exports.messagesTableSQL = messagesTableSQL; exports.newEventsInStream = newEventsInStream; exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition; exports.readMessagesBatch = readMessagesBatch; exports.readProcessorCheckpoint = readProcessorCheckpoint; exports.readStream = readStream; exports.schemaSQL = schemaSQL; exports.sql = sql; exports.sqliteConnection = sqliteConnection; exports.sqliteProjection = sqliteProjection; exports.sqliteRawBatchSQLProjection = sqliteRawBatchSQLProjection; exports.sqliteRawSQLProjection = sqliteRawSQLProjection; exports.storeProcessorCheckpoint = storeProcessorCheckpoint; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.subscriptionsTable = subscriptionsTable; exports.subscriptionsTableSQL = subscriptionsTableSQL;
 //# sourceMappingURL=index.cjs.map