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

package/dist/index.js

@@ -6,19 +6,35 @@ var isSQLiteError = (error) => {
   }
   return false;
 };
+var InMemorySharedCacheSQLiteDatabase = "file::memory:?cache=shared";
 var InMemorySQLiteDatabase = ":memory:";
 var sqliteConnection = (options) => {
-  const db = new sqlite3.Database(options.fileName ?? InMemorySQLiteDatabase);
+  const fileName = options.fileName ?? InMemorySQLiteDatabase;
+  let db;
+  if (fileName.startsWith("file:")) {
+    db = new sqlite3.Database(
+      fileName,
+      sqlite3.OPEN_URI | sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE
+    );
+  } else {
+    db = new sqlite3.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, params ?? [], (err) => {
-        if (err) {
-          reject(err);
-          return;
+      db.run(
+        sql2,
+        params ?? [],
+        function(err) {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve(this);
         }
-        resolve();
-      });
+      );
     }),
     query: (sql2, params) => new Promise((resolve, reject) => {
       db.all(sql2, 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 {
@@ -73,6 +131,7 @@ import { v4 as uuid2 } from "uuid";
 import { v4 as uuid } from "uuid";
 import { TransformStream as TransformStream2 } from "web-streams-polyfill";
 import retry from "async-retry";
+import { v7 as uuid4 } from "uuid";
 import { ReadableStream } from "web-streams-polyfill";
 import "web-streams-polyfill";
 import { TransformStream as TransformStream3 } from "web-streams-polyfill";
@@ -324,7 +383,7 @@ var streamTransformations = {
 var { retry: retry2 } = streamTransformations;
 
 // src/eventStore/schema/appendToStream.ts
-import { v4 as uuid4 } from "uuid";
+import { v4 as uuid5 } from "uuid";
 
 // src/eventStore/schema/typing.ts
 var emmettPrefix = "emt";
@@ -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) => {
@@ -366,15 +428,14 @@ var appendToStream = async (db, streamName, streamType, messages, options) => {
       kind: m.kind ?? "Event",
       metadata: {
         streamName,
-        messageId: uuid4(),
+        messageId: uuid5(),
         streamPosition: BigInt(i + 1),
         ..."metadata" in m ? m.metadata ?? {} : {}
       }
     })
   );
   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 (options?.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,
       options?.partition?.toString() ?? defaultTag
     );
-    const returningId = await db.querySingle(sqlString, values);
-    if (returningId?.global_position == null) {
+    const returningIds = await db.query(sqlString, values);
+    if (returningIds.length === 0 || !returningIds[returningIds.length - 1]?.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 {
@@ -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 ? 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/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 = ({
+  db,
+  batchSize,
+  eachBatch,
+  pullingFrequencyInMs
+}) => {
+  let isRunning = false;
+  let start;
+  const pullMessages = async (options) => {
+    const after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? (await readLastMessageGlobalPosition(db)).currentGlobalPosition ?? 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 = context.fileName ?? options.connectionOptions?.fileName;
+    if (!fileName)
+      throw new EmmettError(
+        `SQLite processor '${options.processorId}' is missing file name. Ensure that you passed it through options`
+      );
+    const db = context.db ?? options.connectionOptions?.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: 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 = options.processors ?? [];
+  let start;
+  let currentMessagePuller;
+  const db = 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" && r.value?.type !== "STOP"
+    ) ? void 0 : {
+      type: "STOP"
+    };
+  };
+  const messagePooler = currentMessagePuller = sqliteEventStoreMessageBatchPuller({
+    db,
+    eachBatch,
+    batchSize: pulling?.batchSize ?? DefaultSQLiteEventStoreProcessorBatchSize,
+    pullingFrequencyInMs: pulling?.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,7 +996,7 @@ var getSQLiteEventStore = (options) => {
   let autoGenerateSchema = false;
   let database;
   const fileName = options.fileName ?? InMemorySQLiteDatabase;
-  const isInMemory = fileName === InMemorySQLiteDatabase;
+  const isInMemory = fileName === InMemorySQLiteDatabase || fileName === InMemorySharedCacheSQLiteDatabase;
   const inlineProjections = (options.projections ?? []).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
   const onBeforeCommitHook = options.hooks?.onBeforeCommit;
   const createConnection = () => {
@@ -608,10 +1030,10 @@ var getSQLiteEventStore = (options) => {
   if (options) {
     autoGenerateSchema = options.schema?.autoMigration === void 0 || options.schema?.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();
@@ -678,7 +1100,12 @@ var getSQLiteEventStore = (options) => {
         lastEventGlobalPosition: appendResult.lastGlobalPosition,
         createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
       };
-    }
+    },
+    consumer: (options2) => sqliteEventStoreConsumer({
+      ...options2 ?? {},
+      fileName,
+      db: database ?? void 0
+    })
   };
 };
 
@@ -725,46 +1152,87 @@ 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 (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;
+      }
+    }
+  } 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;
+      }
+    }
   }
-};
+}
+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,
   appendToStream,
   createEventStoreSchema,
@@ -776,11 +1244,17 @@ export {
   isSQLiteError,
   messagesTable,
   messagesTableSQL,
+  readLastMessageGlobalPosition,
+  readMessagesBatch,
+  readProcessorCheckpoint,
   readStream,
   schemaSQL,
   sql,
   sqliteConnection,
+  storeProcessorCheckpoint,
   streamsTable,
-  streamsTableSQL
+  streamsTableSQL,
+  subscriptionsTable,
+  subscriptionsTableSQL
 };
 //# sourceMappingURL=index.js.map