@event-driven-io/emmett-sqlite 0.40.1 → 0.41.0-alpha.2

package/dist/index.cjs

@@ -527,27 +527,82 @@ var handleProjections = async (options) => {
   }
 };
 var sqliteProjection = (definition) => projection(definition);
-var sqliteRawBatchSQLProjection = (handle, ...canHandle) => sqliteProjection({
-  canHandle,
+var sqliteRawBatchSQLProjection = (options) => sqliteProjection({
+  canHandle: options.canHandle,
   handle: async (events, context) => {
-    const sqls = await handle(events, context);
+    const sqls = await options.evolve(events, context);
     for (const sql2 of sqls) await context.connection.command(sql2);
+  },
+  init: async (context) => {
+    if (options.init) {
+      await options.init(context);
+    }
+    if (options.initSQL) {
+      await context.connection.command(options.initSQL);
+    }
   }
 });
-var sqliteRawSQLProjection = (handle, ...canHandle) => sqliteRawBatchSQLProjection(
-  async (events, context) => {
-    const sqls = [];
-    for (const event of events) {
-      sqls.push(await handle(event, context));
+var sqliteRawSQLProjection = (options) => {
+  const { evolve, ...rest } = options;
+  return sqliteRawBatchSQLProjection({
+    ...rest,
+    evolve: async (events, context) => {
+      const sqls = [];
+      for (const event of events) {
+        const pendingSqls = await evolve(event, context);
+        if (Array.isArray(pendingSqls)) {
+          sqls.push(...pendingSqls);
+        } else {
+          sqls.push(pendingSqls);
+        }
+      }
+      return sqls;
     }
-    return sqls;
-  },
-  ...canHandle
-);
+  });
+};
 
 // src/eventStore/projections/sqliteProjectionSpec.ts
 
 
+// src/connection/sqliteConnectionPool.ts
+var SQLiteConnectionPool = (options) => {
+  const fileName = _nullishCoalesce(options.fileName, () => ( InMemorySQLiteDatabase));
+  const isInMemory = fileName === InMemorySQLiteDatabase || fileName === InMemorySharedCacheSQLiteDatabase;
+  const singletonConnection = _nullishCoalesce(_optionalChain([options, 'access', _14 => _14.connectionOptions, 'optionalAccess', _15 => _15.connection]), () => ( (isInMemory ? sqliteConnection({
+    fileName
+  }) : null)));
+  const isAmbientConnection = _optionalChain([options, 'access', _16 => _16.connectionOptions, 'optionalAccess', _17 => _17.singleton]) === true && _optionalChain([options, 'access', _18 => _18.connectionOptions, 'optionalAccess', _19 => _19.connection]) !== void 0;
+  const createConnection = () => {
+    return _nullishCoalesce(singletonConnection, () => ( sqliteConnection({
+      fileName
+    })));
+  };
+  const closeConnection = (connection) => {
+    if (isInMemory || isAmbientConnection) {
+      return;
+    }
+    connection.close();
+  };
+  const withConnection = async (handler) => {
+    const connection = _nullishCoalesce(singletonConnection, () => ( createConnection()));
+    try {
+      return await handler(connection);
+    } finally {
+      closeConnection(connection);
+    }
+  };
+  return {
+    connection: () => Promise.resolve(createConnection()),
+    withConnection,
+    close: () => {
+      if (singletonConnection && !isAmbientConnection) {
+        closeConnection(singletonConnection);
+      }
+      return Promise.resolve();
+    }
+  };
+};
+
 // src/eventStore/schema/typing.ts
 var emmettPrefix = "emt";
 var globalTag = "global";
@@ -627,9 +682,17 @@ var schemaSQL = [
   messagesTableSQL,
   subscriptionsTableSQL
 ];
-var createEventStoreSchema = async (db) => {
-  for (const sql2 of schemaSQL) {
-    await db.command(sql2);
+var createEventStoreSchema = async (connection, hooks) => {
+  await connection.withTransaction(async () => {
+    if (_optionalChain([hooks, 'optionalAccess', _20 => _20.onBeforeSchemaCreated])) {
+      await hooks.onBeforeSchemaCreated({ connection });
+    }
+    for (const sql2 of schemaSQL) {
+      await connection.command(sql2);
+    }
+  });
+  if (_optionalChain([hooks, 'optionalAccess', _21 => _21.onAfterSchemaCreated])) {
+    await hooks.onAfterSchemaCreated();
   }
 };
 
@@ -651,7 +714,7 @@ var readLastMessageGlobalPosition = async (db, options) => {
          ORDER BY global_position
          LIMIT 1`
       ),
-      [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _14 => _14.partition]), () => ( defaultTag))]
+      [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _22 => _22.partition]), () => ( defaultTag))]
     )
   );
   return {
@@ -674,7 +737,7 @@ var readMessagesBatch = async (db, options) => {
            ORDER BY global_position
            ${limitCondition}`
     ),
-    [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _15 => _15.partition]), () => ( defaultTag))]
+    [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _23 => _23.partition]), () => ( defaultTag))]
   )).map((row) => {
     const rawEvent = {
       type: row.message_type,
@@ -709,7 +772,7 @@ var readMessagesBatch = async (db, options) => {
 var DefaultSQLiteEventStoreProcessorBatchSize = 100;
 var DefaultSQLiteEventStoreProcessorPullingFrequencyInMs = 50;
 var sqliteEventStoreMessageBatchPuller = ({
-  connection,
+  pool,
   batchSize,
   eachBatch,
   pullingFrequencyInMs
@@ -717,14 +780,18 @@ var sqliteEventStoreMessageBatchPuller = ({
   let isRunning = false;
   let start;
   const pullMessages = async (options) => {
-    const after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? await _asyncNullishCoalesce((await readLastMessageGlobalPosition(connection)).currentGlobalPosition, async () => ( 0n)) : options.startFrom.globalPosition;
+    const after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? await _asyncNullishCoalesce((await pool.withConnection(
+      async (connection) => readLastMessageGlobalPosition(connection)
+    )).currentGlobalPosition, async () => ( 0n)) : options.startFrom.globalPosition;
     const readMessagesOptions = {
       after,
       batchSize
     };
     let waitTime = 100;
     do {
-      const { messages, currentGlobalPosition, areEventsLeft } = await readMessagesBatch(connection, readMessagesOptions);
+      const { messages, currentGlobalPosition, areEventsLeft } = await pool.withConnection(
+        (connection) => readMessagesBatch(connection, readMessagesOptions)
+      );
       if (messages.length > 0) {
         const result = await eachBatch({ messages });
         if (result && result.type === "STOP") {
@@ -772,7 +839,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', _16 => _16.expectedStreamVersion])
+    _optionalChain([options, 'optionalAccess', _24 => _24.expectedStreamVersion])
   );
   const messagesToAppend = messages.map(
     (m, i) => ({
@@ -797,7 +864,7 @@ var appendToStream = async (connection, streamName, streamType, messages, option
         expectedStreamVersion
       }
     );
-    if (_optionalChain([options, 'optionalAccess', _17 => _17.onBeforeCommit]))
+    if (_optionalChain([options, 'optionalAccess', _25 => _25.onBeforeCommit]))
       await options.onBeforeCommit(messagesToAppend, { connection });
     return result;
   });
@@ -813,7 +880,7 @@ var appendToStreamRaw = async (connection, streamId, streamType, messages, optio
   let streamPosition;
   let globalPosition;
   try {
-    let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _18 => _18.expectedStreamVersion]), () => ( null));
+    let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _26 => _26.expectedStreamVersion]), () => ( null));
     if (expectedStreamVersion == null) {
       expectedStreamVersion = await getLastStreamPosition(
         connection,
@@ -839,7 +906,7 @@ var appendToStreamRaw = async (connection, streamId, streamType, messages, optio
         [
           streamId,
           messages.length,
-          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _19 => _19.partition]), () => ( streamsTable.columns.partition)),
+          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _27 => _27.partition]), () => ( streamsTable.columns.partition)),
           streamType
         ]
       );
@@ -855,7 +922,7 @@ var appendToStreamRaw = async (connection, streamId, streamType, messages, optio
         [
           messages.length,
           streamId,
-          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _20 => _20.partition]), () => ( streamsTable.columns.partition))
+          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _28 => _28.partition]), () => ( streamsTable.columns.partition))
         ]
       );
     }
@@ -875,10 +942,10 @@ var appendToStreamRaw = async (connection, streamId, streamType, messages, optio
       messages,
       expectedStreamVersion,
       streamId,
-      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _21 => _21.partition, 'optionalAccess', _22 => _22.toString, 'call', _23 => _23()]), () => ( defaultTag))
+      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _29 => _29.partition, 'optionalAccess', _30 => _30.toString, 'call', _31 => _31()]), () => ( defaultTag))
     );
     const returningIds = await connection.query(sqlString, values);
-    if (returningIds.length === 0 || !_optionalChain([returningIds, 'access', _24 => _24[returningIds.length - 1], 'optionalAccess', _25 => _25.global_position])) {
+    if (returningIds.length === 0 || !_optionalChain([returningIds, 'access', _32 => _32[returningIds.length - 1], 'optionalAccess', _33 => _33.global_position])) {
       throw new Error("Could not find global position");
     }
     globalPosition = BigInt(
@@ -899,14 +966,14 @@ var appendToStreamRaw = async (connection, streamId, streamType, messages, optio
   };
 };
 var isOptimisticConcurrencyError = (error) => {
-  return _optionalChain([error, 'optionalAccess', _26 => _26.errno]) !== void 0 && error.errno === 19;
+  return _optionalChain([error, 'optionalAccess', _34 => _34.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', _27 => _27.stream_position]) == null) {
+  if (_optionalChain([result, 'optionalAccess', _35 => _35.stream_position]) == null) {
     expectedStreamVersion = 0n;
   } else {
     expectedStreamVersion = BigInt(result.stream_position);
@@ -916,7 +983,7 @@ async function getLastStreamPosition(connection, 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', _36 => _36.metadata, 'optionalAccess', _37 => _37.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
         throw new Error("Stream position is required");
       }
       const streamPosition = BigInt(message.metadata.streamPosition) + BigInt(expectedStreamVersion);
@@ -928,7 +995,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', _38 => _38.toString, 'call', _39 => _39()]), () => ( 0)),
         message.type,
         message.metadata.messageId,
         false
@@ -970,7 +1037,7 @@ var readProcessorCheckpoint = async (db, options) => {
            WHERE partition = ? AND subscription_id = ?
            LIMIT 1`
       ),
-      [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _32 => _32.partition]), () => ( defaultTag)), options.processorId]
+      [_nullishCoalesce(_optionalChain([options, 'optionalAccess', _40 => _40.partition]), () => ( defaultTag)), options.processorId]
     )
   );
   return {
@@ -990,7 +1057,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', _33 => _33.partition]), () => ( defaultTag))]
+    [streamId, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _41 => _41.partition]), () => ( defaultTag))]
   );
   const messages = results.map((row) => {
     const rawEvent = {
@@ -1047,9 +1114,9 @@ async function storeSubscriptionCheckpointSQLite(db, processorId, version, posit
           [processorId, partition]
         )
       );
-      if (_optionalChain([current_position, 'optionalAccess', _34 => _34.last_processed_position]) === position) {
+      if (_optionalChain([current_position, 'optionalAccess', _42 => _42.last_processed_position]) === position) {
         return 0;
-      } else if (position !== null && current_position !== null && _optionalChain([current_position, 'optionalAccess', _35 => _35.last_processed_position]) > position) {
+      } else if (position !== null && current_position !== null && _optionalChain([current_position, 'optionalAccess', _43 => _43.last_processed_position]) > position) {
         return 2;
       } else {
         return 2;
@@ -1076,7 +1143,7 @@ async function storeSubscriptionCheckpointSQLite(db, processorId, version, posit
           [processorId, partition]
         )
       );
-      if (_optionalChain([current, 'optionalAccess', _36 => _36.last_processed_position]) === position) {
+      if (_optionalChain([current, 'optionalAccess', _44 => _44.last_processed_position]) === position) {
         return 0;
       } else {
         return 2;
@@ -1106,12 +1173,12 @@ var genericSQLiteProcessor = (options) => {
   const { eachMessage } = options;
   let isActive = true;
   const getDb = (context) => {
-    const fileName = _nullishCoalesce(context.fileName, () => ( _optionalChain([options, 'access', _37 => _37.connectionOptions, 'optionalAccess', _38 => _38.fileName])));
+    const fileName = _nullishCoalesce(context.fileName, () => ( _optionalChain([options, 'access', _45 => _45.connectionOptions, 'optionalAccess', _46 => _46.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', _39 => _39.connectionOptions, 'optionalAccess', _40 => _40.connection]))), () => ( sqliteConnection({ fileName })));
+    const connection = _nullishCoalesce(_nullishCoalesce(context.connection, () => ( _optionalChain([options, 'access', _47 => _47.connectionOptions, 'optionalAccess', _48 => _48.connection]))), () => ( sqliteConnection({ fileName })));
     return { connection, fileName };
   };
   return {
@@ -1196,8 +1263,8 @@ var sqliteEventStoreConsumer = (options) => {
   const processors = _nullishCoalesce(options.processors, () => ( []));
   let start;
   let currentMessagePuller;
-  const connection = _nullishCoalesce(options.connection, () => ( sqliteConnection({ fileName: options.fileName })));
-  const eachBatch = async (messagesBatch) => {
+  const pool = _nullishCoalesce(options.pool, () => ( SQLiteConnectionPool(options)));
+  const eachBatch = (messagesBatch) => pool.withConnection(async (connection) => {
     const activeProcessors = processors.filter((s) => s.isActive);
     if (activeProcessors.length === 0)
       return {
@@ -1213,16 +1280,16 @@ var sqliteEventStoreConsumer = (options) => {
       })
     );
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _41 => _41.value, 'optionalAccess', _42 => _42.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _49 => _49.value, 'optionalAccess', _50 => _50.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
-  };
+  });
   const messagePooler = currentMessagePuller = sqliteEventStoreMessageBatchPuller({
-    connection,
+    pool,
     eachBatch,
-    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _43 => _43.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
-    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _44 => _44.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs))
+    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _51 => _51.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
+    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _52 => _52.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs))
   });
   const stop = async () => {
     if (!isRunning) return;
@@ -1254,7 +1321,9 @@ var sqliteEventStoreConsumer = (options) => {
           );
         isRunning = true;
         const startFrom = zipSQLiteEventStoreMessageBatchPullerStartFrom(
-          await Promise.all(processors.map((o) => o.start(connection)))
+          await pool.withConnection(
+            (connection) => Promise.all(processors.map((o) => o.start(connection)))
+          )
         );
         return messagePooler.start({ startFrom });
       })();
@@ -1263,7 +1332,7 @@ var sqliteEventStoreConsumer = (options) => {
     stop,
     close: async () => {
       await stop();
-      connection.close();
+      await pool.close();
       await new Promise((resolve) => setTimeout(resolve, 250));
     }
   };
@@ -1272,63 +1341,49 @@ var sqliteEventStoreConsumer = (options) => {
 // src/eventStore/SQLiteEventStore.ts
 var SQLiteEventStoreDefaultStreamVersion = 0n;
 var getSQLiteEventStore = (options) => {
-  let schemaMigrated = false;
   let autoGenerateSchema = false;
-  let database;
   const fileName = _nullishCoalesce(options.fileName, () => ( InMemorySQLiteDatabase));
-  const isInMemory = fileName === InMemorySQLiteDatabase || fileName === InMemorySharedCacheSQLiteDatabase;
+  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', _45 => _45.hooks, 'optionalAccess', _46 => _46.onBeforeCommit]);
-  const createConnection = () => {
-    if (database != null) {
-      return database;
-    }
-    return sqliteConnection({
-      fileName
-    });
-  };
-  const closeConnection = () => {
-    if (isInMemory) {
-      return;
-    }
-    if (database != null) {
-      database.close();
-      database = null;
-    }
-  };
-  const withConnection = async (handler) => {
-    if (database == null) {
-      database = createConnection();
-    }
-    try {
-      await ensureSchemaExists(database);
-      return await handler(database);
-    } finally {
-      closeConnection();
-    }
-  };
+  const onBeforeCommitHook = _optionalChain([options, 'access', _53 => _53.hooks, 'optionalAccess', _54 => _54.onBeforeCommit]);
+  const withConnection = async (handler) => pool.withConnection(async (database) => {
+    await ensureSchemaExists(database);
+    return await handler(database);
+  });
   if (options) {
-    autoGenerateSchema = _optionalChain([options, 'access', _47 => _47.schema, 'optionalAccess', _48 => _48.autoMigration]) === void 0 || _optionalChain([options, 'access', _49 => _49.schema, 'optionalAccess', _50 => _50.autoMigration]) !== "None";
+    autoGenerateSchema = _optionalChain([options, 'access', _55 => _55.schema, 'optionalAccess', _56 => _56.autoMigration]) === void 0 || _optionalChain([options, 'access', _57 => _57.schema, 'optionalAccess', _58 => _58.autoMigration]) !== "None";
   }
-  const ensureSchemaExists = async (connection) => {
-    if (!autoGenerateSchema) return Promise.resolve();
-    if (!schemaMigrated) {
-      await createEventStoreSchema(connection);
-      schemaMigrated = true;
+  const migrate = (connection) => {
+    if (!migrateSchema) {
+      migrateSchema = createEventStoreSchema(connection, {
+        onBeforeSchemaCreated: async (context) => {
+          for (const projection2 of inlineProjections) {
+            if (projection2.init) {
+              await projection2.init(context);
+            }
+          }
+          if (_optionalChain([options, 'access', _59 => _59.hooks, 'optionalAccess', _60 => _60.onBeforeSchemaCreated])) {
+            await options.hooks.onBeforeSchemaCreated(context);
+          }
+        },
+        onAfterSchemaCreated: _optionalChain([options, 'access', _61 => _61.hooks, 'optionalAccess', _62 => _62.onAfterSchemaCreated])
+      });
     }
-    return Promise.resolve();
+    return migrateSchema;
+  };
+  const ensureSchemaExists = (connection) => {
+    if (!autoGenerateSchema) return Promise.resolve();
+    return migrate(connection);
   };
   return {
     async aggregateStream(streamName, options2) {
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _51 => _51.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _63 => _63.expectedStreamVersion]);
       let state = initialState();
       if (typeof streamName !== "string") {
         throw new Error("Stream name is not string");
       }
-      if (database == null) {
-        database = createConnection();
-      }
       const result = await withConnection(
         (connection) => readStream(connection, streamName, options2.read)
       );
@@ -1352,9 +1407,6 @@ var getSQLiteEventStore = (options) => {
       (connection) => readStream(connection, streamName, options2)
     ),
     appendToStream: async (streamName, events, options2) => {
-      if (database == null) {
-        database = createConnection();
-      }
       const [firstPart, ...rest] = streamName.split("-");
       const streamType = firstPart && rest.length > 0 ? firstPart : "emt:unknown";
       const appendResult = await withConnection(
@@ -1375,7 +1427,7 @@ var getSQLiteEventStore = (options) => {
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _52 => _52.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _64 => _64.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
@@ -1386,8 +1438,13 @@ var getSQLiteEventStore = (options) => {
     consumer: (options2) => sqliteEventStoreConsumer({
       ..._nullishCoalesce(options2, () => ( {})),
       fileName,
-      connection: _nullishCoalesce(database, () => ( void 0))
-    })
+      pool
+    }),
+    schema: {
+      sql: () => schemaSQL.join(""),
+      print: () => console.log(schemaSQL.join("")),
+      migrate: () => pool.withConnection(migrate)
+    }
   };
 };
 
@@ -1395,15 +1452,18 @@ var getSQLiteEventStore = (options) => {
 var SQLiteProjectionSpec = {
   for: (options) => {
     {
-      const connection = options.connection;
+      const connection = _nullishCoalesce(options.connection, () => ( sqliteConnection({
+        fileName: _nullishCoalesce(options.fileName, () => ( InMemorySQLiteDatabase))
+      })));
       const projection2 = options.projection;
+      let wasInitialized = false;
       return (givenEvents) => {
         return {
           when: (events, options2) => {
             const allEvents = [];
             const run = async (connection2) => {
               let globalPosition = 0n;
-              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _53 => _53.numberOfTimes]), () => ( 1));
+              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _65 => _65.numberOfTimes]), () => ( 1));
               for (const event of [
                 ...givenEvents,
                 ...Array.from({ length: numberOfTimes }).flatMap(() => events)
@@ -1423,6 +1483,10 @@ var SQLiteProjectionSpec = {
                   }
                 });
               }
+              if (!wasInitialized && projection2.init) {
+                await projection2.init({ connection: connection2 });
+                wasInitialized = true;
+              }
               await connection2.withTransaction(
                 () => handleProjections({
                   events: allEvents,
@@ -1456,18 +1520,18 @@ var SQLiteProjectionSpec = {
                   if (!isErrorConstructor(args[0])) {
                     assertTrue(
                       args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _54 => _54.toString, 'call', _55 => _55()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _66 => _66.toString, 'call', _67 => _67()])}`
                     );
                     return;
                   }
                   assertTrue(
                     error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _56 => _56.toString, 'call', _57 => _57()])}`
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _68 => _68.toString, 'call', _69 => _69()])}`
                   );
                   if (args[1]) {
                     assertTrue(
                       args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _58 => _58.toString, 'call', _59 => _59()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _70 => _70.toString, 'call', _71 => _71()])}`
                     );
                   }
                 } finally {
@@ -1486,7 +1550,7 @@ var eventInStream = (streamName, event) => {
     ...event,
     metadata: {
       ..._nullishCoalesce(event.metadata, () => ( {})),
-      streamName: _nullishCoalesce(_optionalChain([event, 'access', _60 => _60.metadata, 'optionalAccess', _61 => _61.streamName]), () => ( streamName))
+      streamName: _nullishCoalesce(_optionalChain([event, 'access', _72 => _72.metadata, 'optionalAccess', _73 => _73.streamName]), () => ( streamName))
     }
   };
 };