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

package/dist/index.js

@@ -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 _EmmettError extends Error {
   static 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 options?.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(message2 ?? "That should not ever happened, right?");
+};
+function assertTrue(condition, message2) {
+  if (condition !== true)
+    throw new AssertionError(message2 ?? `Condition is false`);
+}
+function assertOk(obj, message2) {
+  if (!obj) throw new AssertionError(message2 ?? `Condition is not truthy`);
+}
+function assertEqual(expected, actual, message2) {
+  if (expected !== actual)
+    throw new AssertionError(
+      `${message2 ?? "Objects are not equal"}:
+Expected: ${JSONParser.stringify(expected)}
+Actual: ${JSONParser.stringify(actual)}`
+    );
+}
+function assertNotEqual(obj, other, message2) {
+  if (obj === other)
+    throw new AssertionError(
+      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,9 +511,43 @@ var getCheckpoint = (message2) => {
     message2.metadata.streamPosition
   ) : null;
 };
+var projection = (definition) => definition;
 
-// src/eventStore/schema/appendToStream.ts
-import { v4 as uuid4 } from "uuid";
+// 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
+import "@event-driven-io/dumbo";
+import { v4 as uuid5 } from "uuid";
 
 // src/eventStore/schema/typing.ts
 var emmettPrefix = "emt";
@@ -240,7 +580,196 @@ 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 ? 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`
+      ),
+      [options?.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}`
+    ),
+    [options?.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 ? 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 readLastMessageGlobalPosition(connection)).currentGlobalPosition ?? 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
+import { v4 as uuid4 } from "uuid";
 var appendToStream = async (connection, streamName, streamType, messages, options) => {
   if (messages.length === 0) return { success: false };
   const expectedStreamVersion = toExpectedVersion(
@@ -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 ? 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`
       ),
-      [options?.partition ?? defaultTag]
+      [options?.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}`
-    ),
-    [options?.partition ?? defaultTag]
-  )).map((row) => {
+           WHERE stream_id = ? AND partition = ? AND is_archived = FALSE ${fromCondition} ${toCondition}
+           ORDER BY stream_position ASC`,
+    [streamId, options?.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 ? rawEvent.metadata ?? {} : {},
       messageId: row.message_id,
-      streamName: row.stream_id,
+      streamName: streamId,
       streamPosition: BigInt(row.stream_position),
       globalPosition: BigInt(row.global_position)
     };
@@ -547,96 +1012,95 @@ 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`
-      ),
-      [options?.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 readLastMessageGlobalPosition(connection)).currentGlobalPosition ?? 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 (current_position?.last_processed_position === position) {
+        return 0;
+      } else if (position !== null && current_position !== null && current_position?.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 (current?.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,
+      options.version ?? 1,
+      options.newPosition,
+      options.lastProcessedPosition,
+      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) => {
@@ -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) => {
@@ -942,142 +1392,141 @@ 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, options?.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 ? 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 = options2?.numberOfTimes ?? 1;
+              for (const event of [
+                ...givenEvents,
+                ...Array.from({ length: numberOfTimes }).flatMap(() => events)
+              ]) {
+                const metadata = {
+                  globalPosition: ++globalPosition,
+                  streamPosition: globalPosition,
+                  streamName: `test-${uuid5()}`,
+                  messageId: uuid5()
+                };
+                allEvents.push({
+                  ...event,
+                  kind: "Event",
+                  metadata: {
+                    ...metadata,
+                    ..."metadata" in event ? 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(
+                      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: ${error?.toString()}`
+                    );
+                    return;
+                  }
+                  assertTrue(
+                    error instanceof args[0],
+                    `Caught error is not an instance of the expected type: ${error?.toString()}`
+                  );
+                  if (args[1]) {
+                    assertTrue(
+                      args[1](error),
+                      `Error didn't match the error condition: ${error?.toString()}`
+                    );
+                  }
+                } 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 (current_position?.last_processed_position === position) {
-        return 0;
-      } else if (position !== null && current_position !== null && current_position?.last_processed_position > position) {
-        return 2;
-      } else {
-        return 2;
-      }
+var eventInStream = (streamName, event) => {
+  return {
+    ...event,
+    metadata: {
+      ...event.metadata ?? {},
+      streamName: event.metadata?.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 (current?.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,
-      options.version ?? 1,
-      options.newPosition,
-      options.lastProcessedPosition,
-      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;
-  }
-}
+  })
+};
 export {
   InMemorySQLiteDatabase,
   InMemorySharedCacheSQLiteDatabase,
   SQLiteEventStoreDefaultStreamVersion,
+  SQLiteProjectionSpec,
   appendToStream,
+  assertSQLQueryResultMatches,
   createEventStoreSchema,
   defaultTag,
   emmettPrefix,
+  eventInStream,
+  eventsInStream,
+  expectSQL,
   getSQLiteEventStore,
   globalNames,
   globalTag,
+  handleProjections,
   isSQLiteError,
   messagesTable,
   messagesTableSQL,
+  newEventsInStream,
   readLastMessageGlobalPosition,
   readMessagesBatch,
   readProcessorCheckpoint,
@@ -1085,6 +1534,9 @@ export {
   schemaSQL,
   sql,
   sqliteConnection,
+  sqliteProjection,
+  sqliteRawBatchSQLProjection,
+  sqliteRawSQLProjection,
   storeProcessorCheckpoint,
   streamsTable,
   streamsTableSQL,