@event-driven-io/emmett-sqlite 0.36.0 → 0.38.0-alpha.1

package/dist/index.cjs

@@ -130,6 +130,7 @@ var _webstreamspolyfill = require('web-streams-polyfill');
 
 
 
+
 var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
 
 
@@ -203,22 +204,6 @@ var NotifyAboutNoActiveReadersStream = (_class = class extends _webstreamspolyfi
     }
   }
 }, _class);
-var asyncRetry = async (fn, opts) => {
-  if (opts === void 0 || opts.retries === 0) return fn();
-  return _asyncretry2.default.call(void 0, 
-    async (bail) => {
-      try {
-        return await fn();
-      } catch (error2) {
-        if (_optionalChain([opts, 'optionalAccess', _10 => _10.shouldRetryError]) && !opts.shouldRetryError(error2)) {
-          bail(error2);
-        }
-        throw error2;
-      }
-    },
-    _nullishCoalesce(opts, () => ( { retries: 0 }))
-  );
-};
 var ParseError = class extends Error {
   constructor(text) {
     super(`Cannot parse! ${text}`);
@@ -227,19 +212,41 @@ var ParseError = class extends Error {
 var JSONParser = {
   stringify: (value, options) => {
     return JSON.stringify(
-      _optionalChain([options, 'optionalAccess', _11 => _11.map]) ? options.map(value) : value,
+      _optionalChain([options, 'optionalAccess', _10 => _10.map]) ? options.map(value) : value,
       //TODO: Consider adding support to DateTime and adding specific format to mark that's a bigint
       // eslint-disable-next-line @typescript-eslint/no-unsafe-return
       (_, v) => typeof v === "bigint" ? v.toString() : v
     );
   },
   parse: (text, options) => {
-    const parsed = JSON.parse(text, _optionalChain([options, 'optionalAccess', _12 => _12.reviver]));
-    if (_optionalChain([options, 'optionalAccess', _13 => _13.typeCheck]) && !_optionalChain([options, 'optionalAccess', _14 => _14.typeCheck, 'call', _15 => _15(parsed)]))
+    const parsed = JSON.parse(text, _optionalChain([options, 'optionalAccess', _11 => _11.reviver]));
+    if (_optionalChain([options, 'optionalAccess', _12 => _12.typeCheck]) && !_optionalChain([options, 'optionalAccess', _13 => _13.typeCheck, 'call', _14 => _14(parsed)]))
       throw new ParseError(text);
-    return _optionalChain([options, 'optionalAccess', _16 => _16.map]) ? options.map(parsed) : parsed;
+    return _optionalChain([options, 'optionalAccess', _15 => _15.map]) ? options.map(parsed) : parsed;
   }
 };
+var asyncRetry = async (fn, opts) => {
+  if (opts === void 0 || opts.retries === 0) return fn();
+  return _asyncretry2.default.call(void 0, 
+    async (bail) => {
+      try {
+        const result = await fn();
+        if (_optionalChain([opts, 'optionalAccess', _16 => _16.shouldRetryResult]) && opts.shouldRetryResult(result)) {
+          throw new EmmettError(
+            `Retrying because of result: ${JSONParser.stringify(result)}`
+          );
+        }
+        return result;
+      } catch (error2) {
+        if (_optionalChain([opts, 'optionalAccess', _17 => _17.shouldRetryError]) && !opts.shouldRetryError(error2)) {
+          bail(error2);
+        }
+        throw error2;
+      }
+    },
+    _nullishCoalesce(opts, () => ( { retries: 0 }))
+  );
+};
 var filter = (filter2) => new (0, _webstreamspolyfill.TransformStream)({
   transform(chunk, controller) {
     if (filter2(chunk)) {
@@ -417,10 +424,10 @@ var subscriptionsTable = {
 };
 
 // src/eventStore/schema/appendToStream.ts
-var appendToStream = async (db, streamName, streamType, messages, options) => {
+var appendToStream = async (connection, streamName, streamType, messages, options) => {
   if (messages.length === 0) return { success: false };
   const expectedStreamVersion = toExpectedVersion(
-    _optionalChain([options, 'optionalAccess', _17 => _17.expectedStreamVersion])
+    _optionalChain([options, 'optionalAccess', _18 => _18.expectedStreamVersion])
   );
   const messagesToAppend = messages.map(
     (m, i) => ({
@@ -435,9 +442,9 @@ var appendToStream = async (db, streamName, streamType, messages, options) => {
     })
   );
   let result;
-  return await db.withTransaction(async () => {
+  return await connection.withTransaction(async () => {
     result = await appendToStreamRaw(
-      db,
+      connection,
       streamName,
       streamType,
       messagesToAppend,
@@ -445,8 +452,8 @@ var appendToStream = async (db, streamName, streamType, messages, options) => {
         expectedStreamVersion
       }
     );
-    if (_optionalChain([options, 'optionalAccess', _18 => _18.onBeforeCommit]))
-      await options.onBeforeCommit(messagesToAppend, { db });
+    if (_optionalChain([options, 'optionalAccess', _19 => _19.onBeforeCommit]))
+      await options.onBeforeCommit(messagesToAppend, { connection });
     return result;
   });
 };
@@ -457,21 +464,21 @@ var toExpectedVersion = (expected) => {
   if (expected == STREAM_EXISTS) return null;
   return expected;
 };
-var appendToStreamRaw = async (db, streamId, streamType, messages, options) => {
+var appendToStreamRaw = async (connection, streamId, streamType, messages, options) => {
   let streamPosition;
   let globalPosition;
   try {
-    let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _19 => _19.expectedStreamVersion]), () => ( null));
+    let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _20 => _20.expectedStreamVersion]), () => ( null));
     if (expectedStreamVersion == null) {
       expectedStreamVersion = await getLastStreamPosition(
-        db,
+        connection,
         streamId,
         expectedStreamVersion
       );
     }
     let position;
     if (expectedStreamVersion === 0n) {
-      position = await db.querySingle(
+      position = await connection.querySingle(
         `INSERT INTO ${streamsTable.name}
             (stream_id, stream_position, partition, stream_type, stream_metadata, is_archived)
             VALUES  (
@@ -487,12 +494,12 @@ var appendToStreamRaw = async (db, streamId, streamType, messages, options) => {
         [
           streamId,
           messages.length,
-          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _20 => _20.partition]), () => ( streamsTable.columns.partition)),
+          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _21 => _21.partition]), () => ( streamsTable.columns.partition)),
           streamType
         ]
       );
     } else {
-      position = await db.querySingle(
+      position = await connection.querySingle(
         `UPDATE ${streamsTable.name}
             SET stream_position = stream_position + ?
             WHERE stream_id = ?
@@ -503,7 +510,7 @@ var appendToStreamRaw = async (db, streamId, streamType, messages, options) => {
         [
           messages.length,
           streamId,
-          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _21 => _21.partition]), () => ( streamsTable.columns.partition))
+          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _22 => _22.partition]), () => ( streamsTable.columns.partition))
         ]
       );
     }
@@ -523,10 +530,10 @@ var appendToStreamRaw = async (db, streamId, streamType, messages, options) => {
       messages,
       expectedStreamVersion,
       streamId,
-      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _22 => _22.partition, 'optionalAccess', _23 => _23.toString, 'call', _24 => _24()]), () => ( defaultTag))
+      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _23 => _23.partition, 'optionalAccess', _24 => _24.toString, 'call', _25 => _25()]), () => ( defaultTag))
     );
-    const returningIds = await db.query(sqlString, values);
-    if (returningIds.length === 0 || !_optionalChain([returningIds, 'access', _25 => _25[returningIds.length - 1], 'optionalAccess', _26 => _26.global_position])) {
+    const returningIds = await connection.query(sqlString, values);
+    if (returningIds.length === 0 || !_optionalChain([returningIds, 'access', _26 => _26[returningIds.length - 1], 'optionalAccess', _27 => _27.global_position])) {
       throw new Error("Could not find global position");
     }
     globalPosition = BigInt(
@@ -547,14 +554,14 @@ var appendToStreamRaw = async (db, streamId, streamType, messages, options) => {
   };
 };
 var isOptimisticConcurrencyError = (error) => {
-  return _optionalChain([error, 'optionalAccess', _27 => _27.errno]) !== void 0 && error.errno === 19;
+  return _optionalChain([error, 'optionalAccess', _28 => _28.errno]) !== void 0 && error.errno === 19;
 };
-async function getLastStreamPosition(db, streamId, expectedStreamVersion) {
-  const result = await db.querySingle(
+async function getLastStreamPosition(connection, streamId, expectedStreamVersion) {
+  const result = await connection.querySingle(
     `SELECT CAST(stream_position AS VARCHAR) AS stream_position FROM ${streamsTable.name} WHERE stream_id = ?`,
     [streamId]
   );
-  if (_optionalChain([result, 'optionalAccess', _28 => _28.stream_position]) == null) {
+  if (_optionalChain([result, 'optionalAccess', _29 => _29.stream_position]) == null) {
     expectedStreamVersion = 0n;
   } else {
     expectedStreamVersion = BigInt(result.stream_position);
@@ -564,7 +571,7 @@ async function getLastStreamPosition(db, streamId, expectedStreamVersion) {
 var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partition) => {
   const query = messages.reduce(
     (queryBuilder, message) => {
-      if (_optionalChain([message, 'access', _29 => _29.metadata, 'optionalAccess', _30 => _30.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
+      if (_optionalChain([message, 'access', _30 => _30.metadata, 'optionalAccess', _31 => _31.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
         throw new Error("Stream position is required");
       }
       const streamPosition = BigInt(message.metadata.streamPosition) + BigInt(expectedStreamVersion);
@@ -576,7 +583,7 @@ var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partit
         message.kind === "Event" ? "E" : "C",
         JSONParser.stringify(message.data),
         JSONParser.stringify(message.metadata),
-        _nullishCoalesce(_optionalChain([expectedStreamVersion, 'optionalAccess', _31 => _31.toString, 'call', _32 => _32()]), () => ( 0)),
+        _nullishCoalesce(_optionalChain([expectedStreamVersion, 'optionalAccess', _32 => _32.toString, 'call', _33 => _33()]), () => ( 0)),
         message.type,
         message.metadata.messageId,
         false
@@ -680,7 +687,7 @@ var readLastMessageGlobalPosition = async (db, options) => {
          ORDER BY global_position
          LIMIT 1`
       ),
-      [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _33 => _33.partition]), () => ( defaultTag))]
+      [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _34 => _34.partition]), () => ( defaultTag))]
     )
   );
   return {
@@ -703,7 +710,7 @@ var readMessagesBatch = async (db, options) => {
            ORDER BY global_position
            ${limitCondition}`
     ),
-    [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _34 => _34.partition]), () => ( defaultTag))]
+    [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _35 => _35.partition]), () => ( defaultTag))]
   )).map((row) => {
     const rawEvent = {
       type: row.message_type,
@@ -744,7 +751,7 @@ var readProcessorCheckpoint = async (db, options) => {
            WHERE partition = ? AND subscription_id = ?
            LIMIT 1`
       ),
-      [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _35 => _35.partition]), () => ( defaultTag)), options.processorId]
+      [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _36 => _36.partition]), () => ( defaultTag)), options.processorId]
     )
   );
   return {
@@ -756,7 +763,7 @@ var readProcessorCheckpoint = async (db, options) => {
 var DefaultSQLiteEventStoreProcessorBatchSize = 100;
 var DefaultSQLiteEventStoreProcessorPullingFrequencyInMs = 50;
 var sqliteEventStoreMessageBatchPuller = ({
-  db,
+  connection,
   batchSize,
   eachBatch,
   pullingFrequencyInMs
@@ -764,14 +771,14 @@ var sqliteEventStoreMessageBatchPuller = ({
   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 after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? await _asyncNullishCoalesce((await readLastMessageGlobalPosition(connection)).currentGlobalPosition, async () => ( 0n)) : options.startFrom.globalPosition;
     const readMessagesOptions = {
       after,
       batchSize
     };
     let waitTime = 100;
     do {
-      const { messages, currentGlobalPosition, areEventsLeft } = await readMessagesBatch(db, readMessagesOptions);
+      const { messages, currentGlobalPosition, areEventsLeft } = await readMessagesBatch(connection, readMessagesOptions);
       if (messages.length > 0) {
         const result = await eachBatch({ messages });
         if (result && result.type === "STOP") {
@@ -819,23 +826,26 @@ 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])));
+    const fileName = _nullishCoalesce(context.fileName, () => ( _optionalChain([options, 'access', _37 => _37.connectionOptions, 'optionalAccess', _38 => _38.fileName])));
     if (!fileName)
       throw new EmmettError(
         `SQLite processor '${options.processorId}' is missing file name. Ensure that you passed it through options`
       );
-    const db = _nullishCoalesce(_nullishCoalesce(context.db, () => ( _optionalChain([options, 'access', _38 => _38.connectionOptions, 'optionalAccess', _39 => _39.db]))), () => ( sqliteConnection({ fileName })));
-    return { db, fileName };
+    const connection = _nullishCoalesce(_nullishCoalesce(context.connection, () => ( _optionalChain([options, 'access', _39 => _39.connectionOptions, 'optionalAccess', _40 => _40.connection]))), () => ( sqliteConnection({ fileName })));
+    return { connection, fileName };
   };
   return {
     id: options.processorId,
-    start: async (db) => {
+    start: async (connection) => {
       isActive = true;
       if (options.startFrom !== "CURRENT") return options.startFrom;
-      const { lastProcessedPosition } = await readProcessorCheckpoint(db, {
-        processorId: options.processorId,
-        partition: options.partition
-      });
+      const { lastProcessedPosition } = await readProcessorCheckpoint(
+        connection,
+        {
+          processorId: options.processorId,
+          partition: options.partition
+        }
+      );
       if (lastProcessedPosition === null) return "BEGINNING";
       return { globalPosition: lastProcessedPosition };
     },
@@ -844,17 +854,17 @@ var genericSQLiteProcessor = (options) => {
     },
     handle: async ({ messages }, context) => {
       if (!isActive) return;
-      const { db, fileName } = getDb(context);
-      return db.withTransaction(async () => {
+      const { connection, fileName } = getDb(context);
+      return connection.withTransaction(async () => {
         let result = void 0;
         let lastProcessedPosition = null;
         for (const message of messages) {
           const typedMessage = message;
           const messageProcessingResult = await eachMessage(typedMessage, {
-            db,
+            connection,
             fileName
           });
-          await storeProcessorCheckpoint(db, {
+          await storeProcessorCheckpoint(connection, {
             processorId: options.processorId,
             version: options.version,
             lastProcessedPosition,
@@ -886,7 +896,7 @@ var sqliteProjectionProcessor = (options) => {
     processorId: _nullishCoalesce(options.processorId, () => ( `projection:${projection2.name}`)),
     eachMessage: async (event, context) => {
       if (!projection2.canHandle.includes(event.type)) return;
-      await projection2.handle([event], context);
+      await projection2.handle([event], { connection: context.connection });
     },
     ...options
   });
@@ -905,7 +915,7 @@ var sqliteEventStoreConsumer = (options) => {
   const processors = _nullishCoalesce(options.processors, () => ( []));
   let start;
   let currentMessagePuller;
-  const db = _nullishCoalesce(options.db, () => ( sqliteConnection({ fileName: options.fileName })));
+  const connection = _nullishCoalesce(options.connection, () => ( sqliteConnection({ fileName: options.fileName })));
   const eachBatch = async (messagesBatch) => {
     const activeProcessors = processors.filter((s) => s.isActive);
     if (activeProcessors.length === 0)
@@ -915,20 +925,23 @@ var sqliteEventStoreConsumer = (options) => {
       };
     const result = await Promise.allSettled(
       activeProcessors.map((s) => {
-        return s.handle(messagesBatch, { db, fileName: options.fileName });
+        return s.handle(messagesBatch, {
+          connection,
+          fileName: options.fileName
+        });
       })
     );
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _40 => _40.value, 'optionalAccess', _41 => _41.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _41 => _41.value, 'optionalAccess', _42 => _42.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
   };
   const messagePooler = currentMessagePuller = sqliteEventStoreMessageBatchPuller({
-    db,
+    connection,
     eachBatch,
-    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _42 => _42.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
-    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _43 => _43.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs))
+    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _43 => _43.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
+    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _44 => _44.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs))
   });
   const stop = async () => {
     if (!isRunning) return;
@@ -960,7 +973,7 @@ var sqliteEventStoreConsumer = (options) => {
           );
         isRunning = true;
         const startFrom = zipSQLiteEventStoreMessageBatchPullerStartFrom(
-          await Promise.all(processors.map((o) => o.start(db)))
+          await Promise.all(processors.map((o) => o.start(connection)))
         );
         return messagePooler.start({ startFrom });
       })();
@@ -969,7 +982,7 @@ var sqliteEventStoreConsumer = (options) => {
     stop,
     close: async () => {
       await stop();
-      db.close();
+      connection.close();
       await new Promise((resolve) => setTimeout(resolve, 250));
     }
   };
@@ -977,14 +990,14 @@ var sqliteEventStoreConsumer = (options) => {
 
 // src/eventStore/projections/index.ts
 var handleProjections = async (options) => {
-  const { projections: allProjections, events, db } = options;
+  const { projections: allProjections, events, connection } = 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) {
+  for (const projection2 of allProjections) {
+    if (!projection2.canHandle.some((type) => eventTypes.includes(type))) {
+      continue;
+    }
     await projection2.handle(events, {
-      db
+      connection
     });
   }
 };
@@ -998,7 +1011,7 @@ var getSQLiteEventStore = (options) => {
   const fileName = _nullishCoalesce(options.fileName, () => ( InMemorySQLiteDatabase));
   const isInMemory = fileName === InMemorySQLiteDatabase || fileName === InMemorySharedCacheSQLiteDatabase;
   const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
-  const onBeforeCommitHook = _optionalChain([options, 'access', _44 => _44.hooks, 'optionalAccess', _45 => _45.onBeforeCommit]);
+  const onBeforeCommitHook = _optionalChain([options, 'access', _45 => _45.hooks, 'optionalAccess', _46 => _46.onBeforeCommit]);
   const createConnection = () => {
     if (database != null) {
       return database;
@@ -1028,12 +1041,12 @@ var getSQLiteEventStore = (options) => {
     }
   };
   if (options) {
-    autoGenerateSchema = _optionalChain([options, 'access', _46 => _46.schema, 'optionalAccess', _47 => _47.autoMigration]) === void 0 || _optionalChain([options, 'access', _48 => _48.schema, 'optionalAccess', _49 => _49.autoMigration]) !== "None";
+    autoGenerateSchema = _optionalChain([options, 'access', _47 => _47.schema, 'optionalAccess', _48 => _48.autoMigration]) === void 0 || _optionalChain([options, 'access', _49 => _49.schema, 'optionalAccess', _50 => _50.autoMigration]) !== "None";
   }
-  const ensureSchemaExists = async (db) => {
+  const ensureSchemaExists = async (connection) => {
     if (!autoGenerateSchema) return Promise.resolve();
     if (!schemaMigrated) {
-      await createEventStoreSchema(db);
+      await createEventStoreSchema(connection);
       schemaMigrated = true;
     }
     return Promise.resolve();
@@ -1041,7 +1054,7 @@ var getSQLiteEventStore = (options) => {
   return {
     async aggregateStream(streamName, options2) {
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _50 => _50.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _51 => _51.expectedStreamVersion]);
       let state = initialState();
       if (typeof streamName !== "string") {
         throw new Error("Stream name is not string");
@@ -1050,7 +1063,7 @@ var getSQLiteEventStore = (options) => {
         database = createConnection();
       }
       const result = await withConnection(
-        (db) => readStream(db, streamName, options2.read)
+        (connection) => readStream(connection, streamName, options2.read)
       );
       const currentStreamVersion = result.currentStreamVersion;
       assertExpectedVersionMatchesCurrent(
@@ -1068,7 +1081,9 @@ var getSQLiteEventStore = (options) => {
         streamExists: result.streamExists
       };
     },
-    readStream: async (streamName, options2) => withConnection((db) => readStream(db, streamName, options2)),
+    readStream: async (streamName, options2) => withConnection(
+      (connection) => readStream(connection, streamName, options2)
+    ),
     appendToStream: async (streamName, events, options2) => {
       if (database == null) {
         database = createConnection();
@@ -1076,7 +1091,7 @@ var getSQLiteEventStore = (options) => {
       const [firstPart, ...rest] = streamName.split("-");
       const streamType = firstPart && rest.length > 0 ? firstPart : "emt:unknown";
       const appendResult = await withConnection(
-        (db) => appendToStream(db, streamName, streamType, events, {
+        (connection) => appendToStream(connection, streamName, streamType, events, {
           ...options2,
           onBeforeCommit: async (messages, context) => {
             if (inlineProjections.length > 0)
@@ -1093,7 +1108,7 @@ var getSQLiteEventStore = (options) => {
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _51 => _51.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _52 => _52.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
@@ -1104,7 +1119,7 @@ var getSQLiteEventStore = (options) => {
     consumer: (options2) => sqliteEventStoreConsumer({
       ..._nullishCoalesce(options2, () => ( {})),
       fileName,
-      db: _nullishCoalesce(database, () => ( void 0))
+      connection: _nullishCoalesce(database, () => ( void 0))
     })
   };
 };
@@ -1119,8 +1134,9 @@ var readStream = async (db, streamId, options) => {
   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}`,
-    [streamId, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _52 => _52.partition]), () => ( defaultTag))]
+           WHERE stream_id = ? AND partition = ? AND is_archived = FALSE ${fromCondition} ${toCondition}
+           ORDER BY stream_position ASC`,
+    [streamId, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _53 => _53.partition]), () => ( defaultTag))]
   );
   const messages = results.map((row) => {
     const rawEvent = {
@@ -1177,9 +1193,9 @@ async function storeSubscriptionCheckpointSQLite(db, processorId, version, posit
           [processorId, partition]
         )
       );
-      if (_optionalChain([current_position, 'optionalAccess', _53 => _53.last_processed_position]) === position) {
+      if (_optionalChain([current_position, 'optionalAccess', _54 => _54.last_processed_position]) === position) {
         return 0;
-      } else if (position !== null && current_position !== null && _optionalChain([current_position, 'optionalAccess', _54 => _54.last_processed_position]) > position) {
+      } else if (position !== null && current_position !== null && _optionalChain([current_position, 'optionalAccess', _55 => _55.last_processed_position]) > position) {
         return 2;
       } else {
         return 2;
@@ -1206,7 +1222,7 @@ async function storeSubscriptionCheckpointSQLite(db, processorId, version, posit
           [processorId, partition]
         )
       );
-      if (_optionalChain([current, 'optionalAccess', _55 => _55.last_processed_position]) === position) {
+      if (_optionalChain([current, 'optionalAccess', _56 => _56.last_processed_position]) === position) {
         return 0;
       } else {
         return 2;