@event-driven-io/emmett-sqlite 0.34.0 → 0.35.0-alpha.2

package/dist/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;// src/connection/sqliteConnection.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;// src/connection/sqliteConnection.ts
 var _sqlite3 = require('sqlite3'); var _sqlite32 = _interopRequireDefault(_sqlite3);
 var isSQLiteError = (error) => {
   if (error instanceof Error && "code" in error) {
@@ -6,19 +6,35 @@ var isSQLiteError = (error) => {
   }
   return false;
 };
+var InMemorySharedCacheSQLiteDatabase = "file::memory:?cache=shared";
 var InMemorySQLiteDatabase = ":memory:";
 var sqliteConnection = (options) => {
-  const db = new _sqlite32.default.Database(_nullishCoalesce(options.fileName, () => ( InMemorySQLiteDatabase)));
+  const fileName = _nullishCoalesce(options.fileName, () => ( InMemorySQLiteDatabase));
+  let db;
+  if (fileName.startsWith("file:")) {
+    db = new _sqlite32.default.Database(
+      fileName,
+      _sqlite32.default.OPEN_URI | _sqlite32.default.OPEN_READWRITE | _sqlite32.default.OPEN_CREATE
+    );
+  } else {
+    db = new _sqlite32.default.Database(fileName);
+  }
+  db.run("PRAGMA journal_mode = WAL;");
+  let transactionNesting = 0;
   return {
     close: () => db.close(),
     command: (sql2, params) => new Promise((resolve, reject) => {
-      db.run(sql2, _nullishCoalesce(params, () => ( [])), (err) => {
-        if (err) {
-          reject(err);
-          return;
+      db.run(
+        sql2,
+        _nullishCoalesce(params, () => ( [])),
+        function(err) {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve(this);
         }
-        resolve();
-      });
+      );
     }),
     query: (sql2, params) => new Promise((resolve, reject) => {
       db.all(sql2, _nullishCoalesce(params, () => ( [])), (err, result) => {
@@ -37,11 +53,53 @@ var sqliteConnection = (options) => {
         }
         resolve(result);
       });
-    })
+    }),
+    withTransaction: async (fn) => {
+      try {
+        if (transactionNesting++ == 0) {
+          await beginTransaction(db);
+        }
+        const result = await fn();
+        if (transactionNesting === 1) await commitTransaction(db);
+        transactionNesting--;
+        return result;
+      } catch (err) {
+        console.log(err);
+        if (--transactionNesting === 0) await rollbackTransaction(db);
+        throw err;
+      }
+    }
   };
 };
+var beginTransaction = (db) => new Promise((resolve, reject) => {
+  db.run("BEGIN IMMEDIATE TRANSACTION", (err) => {
+    if (err) {
+      reject(err);
+      return;
+    }
+    resolve();
+  });
+});
+var commitTransaction = (db) => new Promise((resolve, reject) => {
+  db.run("COMMIT", (err) => {
+    if (err) {
+      reject(err);
+      return;
+    }
+    resolve();
+  });
+});
+var rollbackTransaction = (db) => new Promise((resolve, reject) => {
+  db.run("ROLLBACK", (err) => {
+    if (err) {
+      reject(err);
+      return;
+    }
+    resolve();
+  });
+});
 
-// ../emmett/dist/chunk-4E7QLAH5.js
+// ../emmett/dist/chunk-BQYVGGNE.js
 var isNumber = (val) => typeof val === "number" && val === val;
 var isString = (val) => typeof val === "string";
 var EmmettError = class _EmmettError extends Error {
@@ -86,6 +144,7 @@ var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefa
 
 
 
+
 var STREAM_EXISTS = "STREAM_EXISTS";
 var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
 var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
@@ -353,6 +412,9 @@ var messagesTable = {
     isArchived: columns.isArchived
   }
 };
+var subscriptionsTable = {
+  name: `${emmettPrefix}_subscriptions`
+};
 
 // src/eventStore/schema/appendToStream.ts
 var appendToStream = async (db, streamName, streamType, messages, options) => {
@@ -373,8 +435,7 @@ var appendToStream = async (db, streamName, streamType, messages, options) => {
     })
   );
   let result;
-  await db.command(`BEGIN TRANSACTION`);
-  try {
+  return await db.withTransaction(async () => {
     result = await appendToStreamRaw(
       db,
       streamName,
@@ -385,17 +446,9 @@ var appendToStream = async (db, streamName, streamType, messages, options) => {
       }
     );
     if (_optionalChain([options, 'optionalAccess', _18 => _18.onBeforeCommit]))
-      await options.onBeforeCommit(messagesToAppend, { connection: db });
-  } catch (err) {
-    await db.command(`ROLLBACK`);
-    throw err;
-  }
-  if (result.success == null || !result.success) {
-    await db.command(`ROLLBACK`);
+      await options.onBeforeCommit(messagesToAppend, { db });
     return result;
-  }
-  await db.command(`COMMIT`);
-  return result;
+  });
 };
 var toExpectedVersion = (expected) => {
   if (expected === void 0) return null;
@@ -472,11 +525,13 @@ var appendToStreamRaw = async (db, streamId, streamType, messages, options) => {
       streamId,
       _nullishCoalesce(_optionalChain([options, 'optionalAccess', _22 => _22.partition, 'optionalAccess', _23 => _23.toString, 'call', _24 => _24()]), () => ( defaultTag))
     );
-    const returningId = await db.querySingle(sqlString, values);
-    if (_optionalChain([returningId, 'optionalAccess', _25 => _25.global_position]) == null) {
+    const returningIds = await db.query(sqlString, values);
+    if (returningIds.length === 0 || !_optionalChain([returningIds, 'access', _25 => _25[returningIds.length - 1], 'optionalAccess', _26 => _26.global_position])) {
       throw new Error("Could not find global position");
     }
-    globalPosition = BigInt(returningId.global_position);
+    globalPosition = BigInt(
+      returningIds[returningIds.length - 1].global_position
+    );
   } catch (err) {
     if (isSQLiteError(err) && isOptimisticConcurrencyError(err)) {
       return {
@@ -492,14 +547,14 @@ var appendToStreamRaw = async (db, streamId, streamType, messages, options) => {
   };
 };
 var isOptimisticConcurrencyError = (error) => {
-  return _optionalChain([error, 'optionalAccess', _26 => _26.errno]) !== void 0 && error.errno === 19;
+  return _optionalChain([error, 'optionalAccess', _27 => _27.errno]) !== void 0 && error.errno === 19;
 };
 async function getLastStreamPosition(db, streamId, expectedStreamVersion) {
   const result = await db.querySingle(
     `SELECT CAST(stream_position AS VARCHAR) AS stream_position FROM ${streamsTable.name} WHERE stream_id = ?`,
     [streamId]
   );
-  if (_optionalChain([result, 'optionalAccess', _27 => _27.stream_position]) == null) {
+  if (_optionalChain([result, 'optionalAccess', _28 => _28.stream_position]) == null) {
     expectedStreamVersion = 0n;
   } else {
     expectedStreamVersion = BigInt(result.stream_position);
@@ -509,7 +564,7 @@ async function getLastStreamPosition(db, streamId, expectedStreamVersion) {
 var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partition) => {
   const query = messages.reduce(
     (queryBuilder, message) => {
-      if (_optionalChain([message, 'access', _28 => _28.metadata, 'optionalAccess', _29 => _29.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
+      if (_optionalChain([message, 'access', _29 => _29.metadata, 'optionalAccess', _30 => _30.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
         throw new Error("Stream position is required");
       }
       const streamPosition = BigInt(message.metadata.streamPosition) + BigInt(expectedStreamVersion);
@@ -521,7 +576,7 @@ var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partit
         message.kind === "Event" ? "E" : "C",
         JSONParser.stringify(message.data),
         JSONParser.stringify(message.metadata),
-        _nullishCoalesce(_optionalChain([expectedStreamVersion, 'optionalAccess', _30 => _30.toString, 'call', _31 => _31()]), () => ( 0)),
+        _nullishCoalesce(_optionalChain([expectedStreamVersion, 'optionalAccess', _31 => _31.toString, 'call', _32 => _32()]), () => ( 0)),
         message.type,
         message.metadata.messageId,
         false
@@ -553,16 +608,383 @@ 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, stream_position, 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', _33 => _33.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', _34 => _34.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/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', _35 => _35.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 = ({
+  db,
+  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(db)).currentGlobalPosition, async () => ( 0n)) : options.startFrom.globalPosition;
+    const readMessagesOptions = {
+      after,
+      batchSize
+    };
+    let waitTime = 100;
+    do {
+      const { messages, currentGlobalPosition, areEventsLeft } = await readMessagesBatch(db, 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/consumers/sqliteProcessor.ts
+var genericSQLiteProcessor = (options) => {
+  const { eachMessage } = options;
+  let isActive = true;
+  const getDb = (context) => {
+    const fileName = _nullishCoalesce(context.fileName, () => ( _optionalChain([options, 'access', _36 => _36.connectionOptions, 'optionalAccess', _37 => _37.fileName])));
+    if (!fileName)
+      throw new EmmettError(
+        `SQLite processor '${options.processorId}' is missing file name. Ensure that you passed it through options`
+      );
+    const db = _nullishCoalesce(_nullishCoalesce(context.db, () => ( _optionalChain([options, 'access', _38 => _38.connectionOptions, 'optionalAccess', _39 => _39.db]))), () => ( sqliteConnection({ fileName })));
+    return { db, fileName };
+  };
+  return {
+    id: options.processorId,
+    start: async (db) => {
+      isActive = true;
+      if (options.startFrom !== "CURRENT") return options.startFrom;
+      const { lastProcessedPosition } = await readProcessorCheckpoint(db, {
+        processorId: options.processorId,
+        partition: options.partition
+      });
+      if (lastProcessedPosition === null) return "BEGINNING";
+      return { globalPosition: lastProcessedPosition };
+    },
+    get isActive() {
+      return isActive;
+    },
+    handle: async ({ messages }, context) => {
+      if (!isActive) return;
+      const { db, fileName } = getDb(context);
+      return db.withTransaction(async () => {
+        let result = void 0;
+        let lastProcessedPosition = null;
+        for (const message of messages) {
+          const typedMessage = message;
+          const messageProcessingResult = await eachMessage(typedMessage, {
+            db,
+            fileName
+          });
+          await storeProcessorCheckpoint(db, {
+            processorId: options.processorId,
+            version: options.version,
+            lastProcessedPosition,
+            newPosition: typedMessage.metadata.globalPosition,
+            partition: options.partition
+          });
+          lastProcessedPosition = typedMessage.metadata.globalPosition;
+          if (messageProcessingResult && messageProcessingResult.type === "STOP") {
+            isActive = false;
+            result = messageProcessingResult;
+            break;
+          }
+          if (options.stopAfter && options.stopAfter(typedMessage)) {
+            isActive = false;
+            result = { type: "STOP", reason: "Stop condition reached" };
+            break;
+          }
+          if (messageProcessingResult && messageProcessingResult.type === "SKIP")
+            continue;
+        }
+        return result;
+      });
+    }
+  };
+};
+var sqliteProjectionProcessor = (options) => {
+  const projection2 = options.projection;
+  return genericSQLiteProcessor({
+    processorId: _nullishCoalesce(options.processorId, () => ( `projection:${projection2.name}`)),
+    eachMessage: async (event, context) => {
+      if (!projection2.canHandle.includes(event.type)) return;
+      await projection2.handle([event], context);
+    },
+    ...options
+  });
+};
+var sqliteProcessor = (options) => {
+  if ("projection" in options) {
+    return sqliteProjectionProcessor(options);
+  }
+  return genericSQLiteProcessor(options);
+};
+
+// src/eventStore/consumers/sqliteEventStoreConsumer.ts
+var sqliteEventStoreConsumer = (options) => {
+  let isRunning = false;
+  const { pulling } = options;
+  const processors = _nullishCoalesce(options.processors, () => ( []));
+  let start;
+  let currentMessagePuller;
+  const db = _nullishCoalesce(options.db, () => ( sqliteConnection({ fileName: options.fileName })));
+  const eachBatch = async (messagesBatch) => {
+    const activeProcessors = processors.filter((s) => s.isActive);
+    if (activeProcessors.length === 0)
+      return {
+        type: "STOP",
+        reason: "No active processors"
+      };
+    const result = await Promise.allSettled(
+      activeProcessors.map((s) => {
+        return s.handle(messagesBatch, { db, fileName: options.fileName });
+      })
+    );
+    return result.some(
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _40 => _40.value, 'optionalAccess', _41 => _41.type]) !== "STOP"
+    ) ? void 0 : {
+      type: "STOP"
+    };
+  };
+  const messagePooler = currentMessagePuller = sqliteEventStoreMessageBatchPuller({
+    db,
+    eachBatch,
+    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _42 => _42.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
+    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _43 => _43.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs))
+  });
+  const stop = async () => {
+    if (!isRunning) return;
+    isRunning = false;
+    if (currentMessagePuller) {
+      await currentMessagePuller.stop();
+      currentMessagePuller = void 0;
+    }
+    await start;
+  };
+  return {
+    processors,
+    get isRunning() {
+      return isRunning;
+    },
+    processor: (options2) => {
+      const processor = sqliteProcessor(options2);
+      processors.push(processor);
+      return processor;
+    },
+    start: () => {
+      if (isRunning) return start;
+      start = (async () => {
+        if (processors.length === 0)
+          return Promise.reject(
+            new EmmettError(
+              "Cannot start consumer without at least a single processor"
+            )
+          );
+        isRunning = true;
+        const startFrom = zipSQLiteEventStoreMessageBatchPullerStartFrom(
+          await Promise.all(processors.map((o) => o.start(db)))
+        );
+        return messagePooler.start({ startFrom });
+      })();
+      return start;
+    },
+    stop,
+    close: async () => {
+      await stop();
+      db.close();
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+  };
+};
+
 // src/eventStore/projections/index.ts
 var handleProjections = async (options) => {
-  const { projections: allProjections, events, connection } = options;
+  const { projections: allProjections, events, db } = options;
   const eventTypes = events.map((e) => e.type);
   const projections = allProjections.filter(
     (p) => p.canHandle.some((type) => eventTypes.includes(type))
   );
   for (const projection2 of projections) {
     await projection2.handle(events, {
-      connection
+      db
     });
   }
 };
@@ -574,9 +996,9 @@ var getSQLiteEventStore = (options) => {
   let autoGenerateSchema = false;
   let database;
   const fileName = _nullishCoalesce(options.fileName, () => ( InMemorySQLiteDatabase));
-  const isInMemory = 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', _32 => _32.hooks, 'optionalAccess', _33 => _33.onBeforeCommit]);
+  const onBeforeCommitHook = _optionalChain([options, 'access', _44 => _44.hooks, 'optionalAccess', _45 => _45.onBeforeCommit]);
   const createConnection = () => {
     if (database != null) {
       return database;
@@ -606,12 +1028,12 @@ var getSQLiteEventStore = (options) => {
     }
   };
   if (options) {
-    autoGenerateSchema = _optionalChain([options, 'access', _34 => _34.schema, 'optionalAccess', _35 => _35.autoMigration]) === void 0 || _optionalChain([options, 'access', _36 => _36.schema, 'optionalAccess', _37 => _37.autoMigration]) !== "None";
+    autoGenerateSchema = _optionalChain([options, 'access', _46 => _46.schema, 'optionalAccess', _47 => _47.autoMigration]) === void 0 || _optionalChain([options, 'access', _48 => _48.schema, 'optionalAccess', _49 => _49.autoMigration]) !== "None";
   }
-  const ensureSchemaExists = async (connection) => {
+  const ensureSchemaExists = async (db) => {
     if (!autoGenerateSchema) return Promise.resolve();
     if (!schemaMigrated) {
-      await createEventStoreSchema(connection);
+      await createEventStoreSchema(db);
       schemaMigrated = true;
     }
     return Promise.resolve();
@@ -619,7 +1041,7 @@ var getSQLiteEventStore = (options) => {
   return {
     async aggregateStream(streamName, options2) {
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _38 => _38.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _50 => _50.expectedStreamVersion]);
       let state = initialState();
       if (typeof streamName !== "string") {
         throw new Error("Stream name is not string");
@@ -671,14 +1093,19 @@ var getSQLiteEventStore = (options) => {
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _39 => _39.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _51 => _51.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
         lastEventGlobalPosition: appendResult.lastGlobalPosition,
         createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
       };
-    }
+    },
+    consumer: (options2) => sqliteEventStoreConsumer({
+      ..._nullishCoalesce(options2, () => ( {})),
+      fileName,
+      db: _nullishCoalesce(database, () => ( void 0))
+    })
   };
 };
 
@@ -693,7 +1120,7 @@ var readStream = async (db, streamId, options) => {
     `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}`,
-    [streamId, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _40 => _40.partition]), () => ( defaultTag))]
+    [streamId, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _52 => _52.partition]), () => ( defaultTag))]
   );
   const messages = results.map((row) => {
     const rawEvent = {
@@ -725,44 +1152,91 @@ var readStream = async (db, streamId, options) => {
   };
 };
 
-// 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, stream_position, 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 schemaSQL = [streamsTableSQL, messagesTableSQL];
-var createEventStoreSchema = async (db) => {
-  for (const sql2 of schemaSQL) {
-    await db.command(sql2);
+// 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', _53 => _53.last_processed_position]) === position) {
+        return 0;
+      } else if (position !== null && current_position !== null && _optionalChain([current_position, 'optionalAccess', _54 => _54.last_processed_position]) > position) {
+        return 2;
+      } else {
+        return 2;
+      }
+    }
+  } 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', _55 => _55.last_processed_position]) === position) {
+        return 0;
+      } else {
+        return 2;
+      }
+    }
   }
-};
+}
+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;
+  }
+}
+
+
+
+
+
+
+
 
 
 
@@ -782,5 +1256,5 @@ var createEventStoreSchema = async (db) => {
 
 
 
-exports.InMemorySQLiteDatabase = InMemorySQLiteDatabase; 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.readStream = readStream; exports.schemaSQL = schemaSQL; exports.sql = sql; exports.sqliteConnection = sqliteConnection; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL;
+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;
 //# sourceMappingURL=index.cjs.map