@event-driven-io/emmett-sqlite 0.42.0-beta.5 → 0.42.0-rc.2

package/dist/index.cjs

@@ -558,6 +558,49 @@ var assertThatArray = (array) => {
     }
   };
 };
+var downcastRecordedMessage = (recordedMessage, options) => {
+  if (!_optionalChain([options, 'optionalAccess', _20 => _20.downcast]))
+    return recordedMessage;
+  const downcasted = options.downcast(
+    recordedMessage
+  );
+  return {
+    ...recordedMessage,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    data: downcasted.data,
+    ..."metadata" in recordedMessage || "metadata" in downcasted ? {
+      metadata: {
+        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
+        ..."metadata" in downcasted ? downcasted.metadata : {}
+      }
+    } : {}
+  };
+};
+var downcastRecordedMessages = (recordedMessages, options) => {
+  if (!_optionalChain([options, 'optionalAccess', _21 => _21.downcast]))
+    return recordedMessages;
+  return recordedMessages.map(
+    (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
+  );
+};
+var upcastRecordedMessage = (recordedMessage, options) => {
+  if (!_optionalChain([options, 'optionalAccess', _22 => _22.upcast]))
+    return recordedMessage;
+  const upcasted = options.upcast(
+    recordedMessage
+  );
+  return {
+    ...recordedMessage,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    data: upcasted.data,
+    ..."metadata" in recordedMessage || "metadata" in upcasted ? {
+      metadata: {
+        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
+        ..."metadata" in upcasted ? upcasted.metadata : {}
+      }
+    } : {}
+  };
+};
 var getCheckpoint = (message2) => {
   return "checkpoint" in message2.metadata ? (
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -859,12 +902,12 @@ var schemaSQL = [
 var createEventStoreSchema = async (connection, hooks) => {
   await connection.withTransaction(async () => {
     await migration_0_42_0_FromSubscriptionsToProcessors(connection);
-    if (_optionalChain([hooks, 'optionalAccess', _20 => _20.onBeforeSchemaCreated])) {
+    if (_optionalChain([hooks, 'optionalAccess', _23 => _23.onBeforeSchemaCreated])) {
       await hooks.onBeforeSchemaCreated({ connection });
     }
     await connection.batchCommand(schemaSQL);
   });
-  if (_optionalChain([hooks, 'optionalAccess', _21 => _21.onAfterSchemaCreated])) {
+  if (_optionalChain([hooks, 'optionalAccess', _24 => _24.onAfterSchemaCreated])) {
     await hooks.onAfterSchemaCreated();
   }
 };
@@ -887,7 +930,7 @@ var readLastMessageGlobalPosition = async (db, options) => {
          ORDER BY global_position
          LIMIT 1`
       ),
-      [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _22 => _22.partition]), () => ( defaultTag2))]
+      [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _25 => _25.partition]), () => ( defaultTag2))]
     )
   );
   return {
@@ -910,7 +953,7 @@ var readMessagesBatch = async (db, options) => {
            ORDER BY global_position
            ${limitCondition}`
     ),
-    [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _23 => _23.partition]), () => ( defaultTag2))]
+    [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _26 => _26.partition]), () => ( defaultTag2))]
   )).map((row) => {
     const rawEvent = {
       type: row.message_type,
@@ -1012,7 +1055,7 @@ var zipSQLiteEventStoreMessageBatchPullerStartFrom = (options) => {
 var appendToStream = async (connection, streamName, streamType, messages, options) => {
   if (messages.length === 0) return { success: false };
   const expectedStreamVersion = toExpectedVersion(
-    _optionalChain([options, 'optionalAccess', _24 => _24.expectedStreamVersion])
+    _optionalChain([options, 'optionalAccess', _27 => _27.expectedStreamVersion])
   );
   const messagesToAppend = messages.map(
     (m, i) => ({
@@ -1032,12 +1075,12 @@ var appendToStream = async (connection, streamName, streamType, messages, option
       connection,
       streamName,
       streamType,
-      messagesToAppend,
+      downcastRecordedMessages(messagesToAppend, _optionalChain([options, 'optionalAccess', _28 => _28.schema, 'optionalAccess', _29 => _29.versioning])),
       {
         expectedStreamVersion
       }
     );
-    if (_optionalChain([options, 'optionalAccess', _25 => _25.onBeforeCommit]))
+    if (_optionalChain([options, 'optionalAccess', _30 => _30.onBeforeCommit]))
       await options.onBeforeCommit(messagesToAppend, { connection });
     return result;
   });
@@ -1053,7 +1096,7 @@ var appendToStreamRaw = async (connection, streamId, streamType, messages, optio
   let streamPosition;
   let globalPosition;
   try {
-    let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _26 => _26.expectedStreamVersion]), () => ( null));
+    let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _31 => _31.expectedStreamVersion]), () => ( null));
     if (expectedStreamVersion == null) {
       expectedStreamVersion = await getLastStreamPosition(
         connection,
@@ -1079,7 +1122,7 @@ var appendToStreamRaw = async (connection, streamId, streamType, messages, optio
         [
           streamId,
           messages.length,
-          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _27 => _27.partition]), () => ( streamsTable.columns.partition)),
+          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _32 => _32.partition]), () => ( streamsTable.columns.partition)),
           streamType
         ]
       );
@@ -1095,7 +1138,7 @@ var appendToStreamRaw = async (connection, streamId, streamType, messages, optio
         [
           messages.length,
           streamId,
-          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _28 => _28.partition]), () => ( streamsTable.columns.partition))
+          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _33 => _33.partition]), () => ( streamsTable.columns.partition))
         ]
       );
     }
@@ -1115,10 +1158,10 @@ var appendToStreamRaw = async (connection, streamId, streamType, messages, optio
       messages,
       expectedStreamVersion,
       streamId,
-      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _29 => _29.partition, 'optionalAccess', _30 => _30.toString, 'call', _31 => _31()]), () => ( defaultTag2))
+      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _34 => _34.partition, 'optionalAccess', _35 => _35.toString, 'call', _36 => _36()]), () => ( defaultTag2))
     );
     const returningIds = await connection.query(sqlString, values);
-    if (returningIds.length === 0 || !_optionalChain([returningIds, 'access', _32 => _32[returningIds.length - 1], 'optionalAccess', _33 => _33.global_position])) {
+    if (returningIds.length === 0 || !_optionalChain([returningIds, 'access', _37 => _37[returningIds.length - 1], 'optionalAccess', _38 => _38.global_position])) {
       throw new Error("Could not find global position");
     }
     globalPosition = BigInt(
@@ -1139,14 +1182,14 @@ var appendToStreamRaw = async (connection, streamId, streamType, messages, optio
   };
 };
 var isOptimisticConcurrencyError = (error) => {
-  return _optionalChain([error, 'optionalAccess', _34 => _34.errno]) !== void 0 && error.errno === 19;
+  return _optionalChain([error, 'optionalAccess', _39 => _39.errno]) !== void 0 && error.errno === 19;
 };
 async function getLastStreamPosition(connection, streamId, expectedStreamVersion) {
   const result = await connection.querySingle(
     `SELECT CAST(stream_position AS VARCHAR) AS stream_position FROM ${streamsTable.name} WHERE stream_id = ?`,
     [streamId]
   );
-  if (_optionalChain([result, 'optionalAccess', _35 => _35.stream_position]) == null) {
+  if (_optionalChain([result, 'optionalAccess', _40 => _40.stream_position]) == null) {
     expectedStreamVersion = 0n;
   } else {
     expectedStreamVersion = BigInt(result.stream_position);
@@ -1156,7 +1199,7 @@ async function getLastStreamPosition(connection, streamId, expectedStreamVersion
 var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partition) => {
   const query = messages.reduce(
     (queryBuilder, message) => {
-      if (_optionalChain([message, 'access', _36 => _36.metadata, 'optionalAccess', _37 => _37.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
+      if (_optionalChain([message, 'access', _41 => _41.metadata, 'optionalAccess', _42 => _42.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
         throw new Error("Stream position is required");
       }
       const streamPosition = BigInt(message.metadata.streamPosition) + BigInt(expectedStreamVersion);
@@ -1168,7 +1211,7 @@ var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partit
         message.kind === "Event" ? "E" : "C",
         JSONParser.stringify(message.data),
         JSONParser.stringify(message.metadata),
-        _nullishCoalesce(_optionalChain([expectedStreamVersion, 'optionalAccess', _38 => _38.toString, 'call', _39 => _39()]), () => ( 0)),
+        _nullishCoalesce(_optionalChain([expectedStreamVersion, 'optionalAccess', _43 => _43.toString, 'call', _44 => _44()]), () => ( 0)),
         message.type,
         message.metadata.messageId,
         false
@@ -1210,7 +1253,7 @@ var readProcessorCheckpoint = async (db, options) => {
            WHERE partition = ? AND processor_id = ?
            LIMIT 1`
       ),
-      [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _40 => _40.partition]), () => ( defaultTag2)), options.processorId]
+      [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _45 => _45.partition]), () => ( defaultTag2)), options.processorId]
     )
   );
   return {
@@ -1220,9 +1263,9 @@ var readProcessorCheckpoint = async (db, options) => {
 
 // src/eventStore/schema/readStream.ts
 var readStream = async (db, streamId, options) => {
-  const fromCondition = options && "from" in options ? `AND stream_position >= ${options.from}` : "";
+  const fromCondition = _optionalChain([options, 'optionalAccess', _46 => _46.from]) ? `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
+    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _47 => _47.to]), () => ( (_optionalChain([options, 'optionalAccess', _48 => _48.maxCount]) ? (_nullishCoalesce(options.from, () => ( 0n))) + options.maxCount : NaN)))
   );
   const toCondition = !isNaN(to) ? `AND stream_position <= ${to}` : "";
   const results = await db.query(
@@ -1230,7 +1273,7 @@ var readStream = async (db, streamId, options) => {
            FROM ${messagesTable.name}
            WHERE stream_id = ? AND partition = ? AND is_archived = FALSE ${fromCondition} ${toCondition}
            ORDER BY stream_position ASC`,
-    [streamId, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _41 => _41.partition]), () => ( defaultTag2))]
+    [streamId, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _49 => _49.partition]), () => ( defaultTag2))]
   );
   const messages = results.map((row) => {
     const rawEvent = {
@@ -1245,11 +1288,12 @@ var readStream = async (db, streamId, options) => {
       streamPosition: BigInt(row.stream_position),
       globalPosition: BigInt(row.global_position)
     };
-    return {
+    const event = {
       ...rawEvent,
       kind: "Event",
       metadata
     };
+    return upcastRecordedMessage(event, _optionalChain([options, 'optionalAccess', _50 => _50.schema, 'optionalAccess', _51 => _51.versioning]));
   });
   return messages.length > 0 ? {
     currentStreamVersion: messages[messages.length - 1].metadata.streamPosition,
@@ -1296,7 +1340,7 @@ async function storeSubscriptionCheckpointSQLite(db, processorId, version, posit
           [processorId, partition]
         )
       );
-      const currentPosition = current_position && _optionalChain([current_position, 'optionalAccess', _42 => _42.last_processed_checkpoint]) !== null ? BigInt(current_position.last_processed_checkpoint) : null;
+      const currentPosition = current_position && _optionalChain([current_position, 'optionalAccess', _52 => _52.last_processed_checkpoint]) !== null ? BigInt(current_position.last_processed_checkpoint) : null;
       if (currentPosition === position) {
         return 0;
       } else if (position !== null && currentPosition !== null && currentPosition > position) {
@@ -1332,7 +1376,7 @@ async function storeSubscriptionCheckpointSQLite(db, processorId, version, posit
           [processorId, partition]
         )
       );
-      const currentPosition = current && _optionalChain([current, 'optionalAccess', _43 => _43.last_processed_checkpoint]) !== null ? BigInt(current.last_processed_checkpoint) : null;
+      const currentPosition = current && _optionalChain([current, 'optionalAccess', _53 => _53.last_processed_checkpoint]) !== null ? BigInt(current.last_processed_checkpoint) : null;
       if (currentPosition === position) {
         return 0;
       } else {
@@ -1363,12 +1407,12 @@ var genericSQLiteProcessor = (options) => {
   const { eachMessage } = options;
   let isActive = true;
   const getDb = (context) => {
-    const fileName = _nullishCoalesce(context.fileName, () => ( _optionalChain([options, 'access', _44 => _44.connectionOptions, 'optionalAccess', _45 => _45.fileName])));
+    const fileName = _nullishCoalesce(context.fileName, () => ( _optionalChain([options, 'access', _54 => _54.connectionOptions, 'optionalAccess', _55 => _55.fileName])));
     if (!fileName)
       throw new EmmettError(
         `SQLite processor '${options.processorId}' is missing file name. Ensure that you passed it through options`
       );
-    const connection = _nullishCoalesce(_nullishCoalesce(context.connection, () => ( _optionalChain([options, 'access', _46 => _46.connectionOptions, 'optionalAccess', _47 => _47.connection]))), () => ( sqliteConnection({ fileName })));
+    const connection = _nullishCoalesce(_nullishCoalesce(context.connection, () => ( _optionalChain([options, 'access', _56 => _56.connectionOptions, 'optionalAccess', _57 => _57.connection]))), () => ( sqliteConnection({ fileName })));
     return { connection, fileName };
   };
   return {
@@ -1470,7 +1514,7 @@ var sqliteEventStoreConsumer = (options) => {
       })
     );
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _48 => _48.value, 'optionalAccess', _49 => _49.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _58 => _58.value, 'optionalAccess', _59 => _59.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
@@ -1478,8 +1522,8 @@ var sqliteEventStoreConsumer = (options) => {
   const messagePooler = currentMessagePuller = sqliteEventStoreMessageBatchPuller({
     pool,
     eachBatch,
-    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _50 => _50.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
-    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _51 => _51.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs))
+    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _60 => _60.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
+    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _61 => _61.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs))
   });
   const stop = async () => {
     if (!isRunning) return;
@@ -1536,9 +1580,9 @@ var streamExists = async (db, streamId, options) => {
         from ${streamsTable.name}
         WHERE stream_id = ? AND partition = ? AND is_archived = FALSE)
       `,
-    [streamId, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _52 => _52.partition]), () => ( defaultTag2))]
+    [streamId, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _62 => _62.partition]), () => ( defaultTag2))]
   );
-  return _nullishCoalesce(_optionalChain([queryResult, 'access', _53 => _53[0], 'optionalAccess', _54 => _54.exists]), () => ( false));
+  return _nullishCoalesce(_optionalChain([queryResult, 'access', _63 => _63[0], 'optionalAccess', _64 => _64.exists]), () => ( false));
 };
 
 // src/eventStore/SQLiteEventStore.ts
@@ -1549,13 +1593,13 @@ var getSQLiteEventStore = (options) => {
   const pool = _nullishCoalesce(options.pool, () => ( SQLiteConnectionPool(options)));
   let migrateSchema = void 0;
   const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
-  const onBeforeCommitHook = _optionalChain([options, 'access', _55 => _55.hooks, 'optionalAccess', _56 => _56.onBeforeCommit]);
+  const onBeforeCommitHook = _optionalChain([options, 'access', _65 => _65.hooks, 'optionalAccess', _66 => _66.onBeforeCommit]);
   const withConnection = async (handler) => pool.withConnection(async (database) => {
     await ensureSchemaExists(database);
     return await handler(database);
   });
   if (options) {
-    autoGenerateSchema = _optionalChain([options, 'access', _57 => _57.schema, 'optionalAccess', _58 => _58.autoMigration]) === void 0 || _optionalChain([options, 'access', _59 => _59.schema, 'optionalAccess', _60 => _60.autoMigration]) !== "None";
+    autoGenerateSchema = _optionalChain([options, 'access', _67 => _67.schema, 'optionalAccess', _68 => _68.autoMigration]) === void 0 || _optionalChain([options, 'access', _69 => _69.schema, 'optionalAccess', _70 => _70.autoMigration]) !== "None";
   }
   const migrate = (connection) => {
     if (!migrateSchema) {
@@ -1571,11 +1615,11 @@ var getSQLiteEventStore = (options) => {
               });
             }
           }
-          if (_optionalChain([options, 'access', _61 => _61.hooks, 'optionalAccess', _62 => _62.onBeforeSchemaCreated])) {
+          if (_optionalChain([options, 'access', _71 => _71.hooks, 'optionalAccess', _72 => _72.onBeforeSchemaCreated])) {
             await options.hooks.onBeforeSchemaCreated(context);
           }
         },
-        onAfterSchemaCreated: _optionalChain([options, 'access', _63 => _63.hooks, 'optionalAccess', _64 => _64.onAfterSchemaCreated])
+        onAfterSchemaCreated: _optionalChain([options, 'access', _73 => _73.hooks, 'optionalAccess', _74 => _74.onAfterSchemaCreated])
       });
     }
     return migrateSchema;
@@ -1587,13 +1631,13 @@ var getSQLiteEventStore = (options) => {
   return {
     async aggregateStream(streamName, options2) {
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _65 => _65.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _75 => _75.expectedStreamVersion]);
       let state = initialState();
       if (typeof streamName !== "string") {
         throw new Error("Stream name is not string");
       }
       const result = await withConnection(
-        (connection) => readStream(connection, streamName, options2.read)
+        (connection) => readStream(connection, streamName, read)
       );
       const currentStreamVersion = result.currentStreamVersion;
       assertExpectedVersionMatchesCurrent(
@@ -1612,7 +1656,11 @@ var getSQLiteEventStore = (options) => {
       };
     },
     readStream: async (streamName, options2) => withConnection(
-      (connection) => readStream(connection, streamName, options2)
+      (connection) => readStream(
+        connection,
+        streamName,
+        options2
+      )
     ),
     appendToStream: async (streamName, events, options2) => {
       const [firstPart, ...rest] = streamName.split("-");
@@ -1635,7 +1683,7 @@ var getSQLiteEventStore = (options) => {
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _66 => _66.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _76 => _76.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
@@ -1676,7 +1724,7 @@ var SQLiteProjectionSpec = {
             const allEvents = [];
             const run = async (connection2) => {
               let globalPosition = 0n;
-              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _67 => _67.numberOfTimes]), () => ( 1));
+              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _77 => _77.numberOfTimes]), () => ( 1));
               for (const event of [
                 ...givenEvents,
                 ...Array.from({ length: numberOfTimes }).flatMap(() => events)
@@ -1738,18 +1786,18 @@ var SQLiteProjectionSpec = {
                   if (!isErrorConstructor(args[0])) {
                     assertTrue(
                       args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _68 => _68.toString, 'call', _69 => _69()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _78 => _78.toString, 'call', _79 => _79()])}`
                     );
                     return;
                   }
                   assertTrue(
                     error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _70 => _70.toString, 'call', _71 => _71()])}`
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _80 => _80.toString, 'call', _81 => _81()])}`
                   );
                   if (args[1]) {
                     assertTrue(
                       args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _72 => _72.toString, 'call', _73 => _73()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _82 => _82.toString, 'call', _83 => _83()])}`
                     );
                   }
                 } finally {
@@ -1768,7 +1816,7 @@ var eventInStream = (streamName, event) => {
     ...event,
     metadata: {
       ..._nullishCoalesce(event.metadata, () => ( {})),
-      streamName: _nullishCoalesce(_optionalChain([event, 'access', _74 => _74.metadata, 'optionalAccess', _75 => _75.streamName]), () => ( streamName))
+      streamName: _nullishCoalesce(_optionalChain([event, 'access', _84 => _84.metadata, 'optionalAccess', _85 => _85.streamName]), () => ( streamName))
     }
   };
 };