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

package/dist/index.d.cts

@@ -22,6 +22,23 @@ type SQLiteConnectionOptions = {
 };
 declare const sqliteConnection: (options: SQLiteConnectionOptions) => SQLiteConnection;
 
+type SQLiteConnectionPoolOptions = {
+    fileName: InMemorySQLiteDatabase | InMemorySharedCacheSQLiteDatabase | string | undefined;
+    connectionOptions?: {
+        singleton: true;
+        connection?: SQLiteConnection;
+    } | {
+        singleton?: false;
+        connection?: never;
+    };
+};
+type SQLiteConnectionPool = {
+    connection: () => Promise<SQLiteConnection>;
+    withConnection: <Result = unknown>(handle: (connection: SQLiteConnection) => Promise<Result>) => Promise<Result>;
+    close: () => Promise<void>;
+};
+declare const SQLiteConnectionPool: (options: SQLiteConnectionPoolOptions) => SQLiteConnectionPool;
+
 type SQLiteEventStoreMessageBatchPullerStartFrom = {
     globalPosition: bigint;
 } | 'BEGINNING' | 'END';
@@ -107,16 +124,29 @@ declare const SQLiteEventStoreDefaultStreamVersion = 0n;
 interface SQLiteEventStore extends EventStore<SQLiteReadEventMetadata> {
     appendToStream<EventType extends Event>(streamName: string, events: EventType[], options?: AppendToStreamOptions): Promise<AppendToStreamResultWithGlobalPosition>;
     consumer<ConsumerEventType extends Event = Event>(options?: SQLiteEventStoreConsumerConfig<ConsumerEventType>): SQLiteEventStoreConsumer<ConsumerEventType>;
+    schema: {
+        sql(): string;
+        print(): void;
+        migrate(): Promise<void>;
+    };
 }
 type SQLiteReadEventMetadata = ReadEventMetadataWithGlobalPosition;
 type SQLiteReadEvent<EventType extends Event = Event> = ReadEvent<EventType, SQLiteReadEventMetadata>;
+type SQLiteEventStoreConnectionOptions = {
+    connection: SQLiteConnection;
+};
 type SQLiteEventStoreOptions = {
-    fileName: InMemorySQLiteDatabase | InMemorySharedCacheSQLiteDatabase | string | undefined;
     projections?: ProjectionRegistration<'inline', SQLiteReadEventMetadata, SQLiteProjectionHandlerContext>[];
     schema?: {
         autoMigration?: 'None' | 'CreateOrUpdate';
     };
     hooks?: {
+        /**
+         * This hook will be called **BEFORE** event store schema is created
+         */
+        onBeforeSchemaCreated?: (context: {
+            connection: SQLiteConnection;
+        }) => Promise<void> | void;
         /**
          * This hook will be called **BEFORE** events were stored in the event store.
          * @type {BeforeEventStoreCommitHandler<SQLiteEventStore, HandlerContext>}
@@ -124,7 +154,13 @@ type SQLiteEventStoreOptions = {
         onBeforeCommit?: BeforeEventStoreCommitHandler<SQLiteEventStore, {
             connection: SQLiteConnection;
         }>;
+        /**
+         * This hook will be called **AFTER** event store schema was created
+         */
+        onAfterSchemaCreated?: () => Promise<void> | void;
     };
+} & SQLiteConnectionPoolOptions & {
+    pool?: SQLiteConnectionPool;
 };
 declare const getSQLiteEventStore: (options: SQLiteEventStoreOptions) => SQLiteEventStore;
 
@@ -140,8 +176,20 @@ type SQLiteProjectionHandlerOptions<EventType extends Event = Event> = {
 };
 declare const handleProjections: <EventType extends Event = Event>(options: SQLiteProjectionHandlerOptions<EventType>) => Promise<void>;
 declare const sqliteProjection: <EventType extends Event>(definition: SQLiteProjectionDefinition<EventType>) => SQLiteProjectionDefinition<EventType>;
-declare const sqliteRawBatchSQLProjection: <EventType extends Event>(handle: (events: EventType[], context: SQLiteProjectionHandlerContext) => Promise<string[]> | string[], ...canHandle: CanHandle<EventType>) => SQLiteProjectionDefinition<EventType>;
-declare const sqliteRawSQLProjection: <EventType extends Event>(handle: (event: EventType, context: SQLiteProjectionHandlerContext) => Promise<string> | string, ...canHandle: CanHandle<EventType>) => SQLiteProjectionDefinition<EventType>;
+type SQLiteRawBatchSQLProjection<EventType extends Event> = {
+    evolve: (events: EventType[], context: SQLiteProjectionHandlerContext) => Promise<string[]> | string[];
+    canHandle: CanHandle<EventType>;
+    initSQL?: string;
+    init?: (context: SQLiteProjectionHandlerContext) => void | Promise<void>;
+};
+declare const sqliteRawBatchSQLProjection: <EventType extends Event>(options: SQLiteRawBatchSQLProjection<EventType>) => SQLiteProjectionDefinition<EventType>;
+type SQLiteRawSQLProjection<EventType extends Event> = {
+    evolve: (events: EventType, context: SQLiteProjectionHandlerContext) => Promise<string[]> | string[] | Promise<string> | string;
+    canHandle: CanHandle<EventType>;
+    initSQL?: string;
+    init?: (context: SQLiteProjectionHandlerContext) => void | Promise<void>;
+};
+declare const sqliteRawSQLProjection: <EventType extends Event>(options: SQLiteRawSQLProjection<EventType>) => SQLiteProjectionDefinition<EventType>;
 
 type SQLiteProjectionSpecEvent<EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = EventType & {
     metadata?: Partial<EventMetaDataType>;
@@ -153,7 +201,8 @@ type SQLiteProjectionAssert = (options: {
     connection: SQLiteConnection;
 }) => Promise<void | boolean>;
 type SQLiteProjectionSpecOptions<EventType extends Event> = {
-    connection: SQLiteConnection;
+    fileName?: string;
+    connection?: SQLiteConnection;
     projection: SQLiteProjectionDefinition<EventType>;
 };
 type SQLiteProjectionSpec<EventType extends Event> = (givenEvents: SQLiteProjectionSpecEvent<EventType>[]) => {
@@ -252,7 +301,7 @@ declare const streamsTableSQL: string;
 declare const messagesTableSQL: string;
 declare const subscriptionsTableSQL: string;
 declare const schemaSQL: string[];
-declare const createEventStoreSchema: (db: SQLiteConnection) => Promise<void>;
+declare const createEventStoreSchema: (connection: SQLiteConnection, hooks?: SQLiteEventStoreOptions["hooks"]) => Promise<void>;
 
 declare const emmettPrefix = "emt";
 declare const globalTag = "global";
@@ -286,4 +335,4 @@ declare const subscriptionsTable: {
     name: string;
 };
 
-export { type AppendEventResult, type EventHandler, InMemorySQLiteDatabase, InMemorySharedCacheSQLiteDatabase, type Parameters$1 as Parameters, type ReadLastMessageGlobalPositionResult, type ReadMessagesBatchOptions, type ReadMessagesBatchResult, type ReadProcessorCheckpointResult, type SQLiteConnection, type SQLiteError, type SQLiteEventStore, SQLiteEventStoreDefaultStreamVersion, type SQLiteEventStoreOptions, type SQLiteProjectionAssert, type SQLiteProjectionDefinition, type SQLiteProjectionHandler, type SQLiteProjectionHandlerContext, type SQLiteProjectionHandlerOptions, SQLiteProjectionSpec, type SQLiteProjectionSpecEvent, type SQLiteProjectionSpecOptions, type SQLiteProjectionSpecWhenOptions, type SQLiteReadEvent, type SQLiteReadEventMetadata, type StoreLastProcessedProcessorPositionResult, appendToStream, assertSQLQueryResultMatches, createEventStoreSchema, defaultTag, emmettPrefix, eventInStream, eventsInStream, expectSQL, getSQLiteEventStore, globalNames, globalTag, handleProjections, isSQLiteError, messagesTable, messagesTableSQL, newEventsInStream, readLastMessageGlobalPosition, readMessagesBatch, readProcessorCheckpoint, readStream, schemaSQL, sql, sqliteConnection, sqliteProjection, sqliteRawBatchSQLProjection, sqliteRawSQLProjection, storeProcessorCheckpoint, streamsTable, streamsTableSQL, subscriptionsTable, subscriptionsTableSQL };
+export { type AppendEventResult, type EventHandler, InMemorySQLiteDatabase, InMemorySharedCacheSQLiteDatabase, type Parameters$1 as Parameters, type ReadLastMessageGlobalPositionResult, type ReadMessagesBatchOptions, type ReadMessagesBatchResult, type ReadProcessorCheckpointResult, type SQLiteConnection, type SQLiteError, type SQLiteEventStore, type SQLiteEventStoreConnectionOptions, SQLiteEventStoreDefaultStreamVersion, type SQLiteEventStoreOptions, type SQLiteProjectionAssert, type SQLiteProjectionDefinition, type SQLiteProjectionHandler, type SQLiteProjectionHandlerContext, type SQLiteProjectionHandlerOptions, SQLiteProjectionSpec, type SQLiteProjectionSpecEvent, type SQLiteProjectionSpecOptions, type SQLiteProjectionSpecWhenOptions, type SQLiteRawBatchSQLProjection, type SQLiteRawSQLProjection, type SQLiteReadEvent, type SQLiteReadEventMetadata, type StoreLastProcessedProcessorPositionResult, appendToStream, assertSQLQueryResultMatches, createEventStoreSchema, defaultTag, emmettPrefix, eventInStream, eventsInStream, expectSQL, getSQLiteEventStore, globalNames, globalTag, handleProjections, isSQLiteError, messagesTable, messagesTableSQL, newEventsInStream, readLastMessageGlobalPosition, readMessagesBatch, readProcessorCheckpoint, readStream, schemaSQL, sql, sqliteConnection, sqliteProjection, sqliteRawBatchSQLProjection, sqliteRawSQLProjection, storeProcessorCheckpoint, streamsTable, streamsTableSQL, subscriptionsTable, subscriptionsTableSQL };

package/dist/index.d.ts

@@ -22,6 +22,23 @@ type SQLiteConnectionOptions = {
 };
 declare const sqliteConnection: (options: SQLiteConnectionOptions) => SQLiteConnection;
 
+type SQLiteConnectionPoolOptions = {
+    fileName: InMemorySQLiteDatabase | InMemorySharedCacheSQLiteDatabase | string | undefined;
+    connectionOptions?: {
+        singleton: true;
+        connection?: SQLiteConnection;
+    } | {
+        singleton?: false;
+        connection?: never;
+    };
+};
+type SQLiteConnectionPool = {
+    connection: () => Promise<SQLiteConnection>;
+    withConnection: <Result = unknown>(handle: (connection: SQLiteConnection) => Promise<Result>) => Promise<Result>;
+    close: () => Promise<void>;
+};
+declare const SQLiteConnectionPool: (options: SQLiteConnectionPoolOptions) => SQLiteConnectionPool;
+
 type SQLiteEventStoreMessageBatchPullerStartFrom = {
     globalPosition: bigint;
 } | 'BEGINNING' | 'END';
@@ -107,16 +124,29 @@ declare const SQLiteEventStoreDefaultStreamVersion = 0n;
 interface SQLiteEventStore extends EventStore<SQLiteReadEventMetadata> {
     appendToStream<EventType extends Event>(streamName: string, events: EventType[], options?: AppendToStreamOptions): Promise<AppendToStreamResultWithGlobalPosition>;
     consumer<ConsumerEventType extends Event = Event>(options?: SQLiteEventStoreConsumerConfig<ConsumerEventType>): SQLiteEventStoreConsumer<ConsumerEventType>;
+    schema: {
+        sql(): string;
+        print(): void;
+        migrate(): Promise<void>;
+    };
 }
 type SQLiteReadEventMetadata = ReadEventMetadataWithGlobalPosition;
 type SQLiteReadEvent<EventType extends Event = Event> = ReadEvent<EventType, SQLiteReadEventMetadata>;
+type SQLiteEventStoreConnectionOptions = {
+    connection: SQLiteConnection;
+};
 type SQLiteEventStoreOptions = {
-    fileName: InMemorySQLiteDatabase | InMemorySharedCacheSQLiteDatabase | string | undefined;
     projections?: ProjectionRegistration<'inline', SQLiteReadEventMetadata, SQLiteProjectionHandlerContext>[];
     schema?: {
         autoMigration?: 'None' | 'CreateOrUpdate';
     };
     hooks?: {
+        /**
+         * This hook will be called **BEFORE** event store schema is created
+         */
+        onBeforeSchemaCreated?: (context: {
+            connection: SQLiteConnection;
+        }) => Promise<void> | void;
         /**
          * This hook will be called **BEFORE** events were stored in the event store.
          * @type {BeforeEventStoreCommitHandler<SQLiteEventStore, HandlerContext>}
@@ -124,7 +154,13 @@ type SQLiteEventStoreOptions = {
         onBeforeCommit?: BeforeEventStoreCommitHandler<SQLiteEventStore, {
             connection: SQLiteConnection;
         }>;
+        /**
+         * This hook will be called **AFTER** event store schema was created
+         */
+        onAfterSchemaCreated?: () => Promise<void> | void;
     };
+} & SQLiteConnectionPoolOptions & {
+    pool?: SQLiteConnectionPool;
 };
 declare const getSQLiteEventStore: (options: SQLiteEventStoreOptions) => SQLiteEventStore;
 
@@ -140,8 +176,20 @@ type SQLiteProjectionHandlerOptions<EventType extends Event = Event> = {
 };
 declare const handleProjections: <EventType extends Event = Event>(options: SQLiteProjectionHandlerOptions<EventType>) => Promise<void>;
 declare const sqliteProjection: <EventType extends Event>(definition: SQLiteProjectionDefinition<EventType>) => SQLiteProjectionDefinition<EventType>;
-declare const sqliteRawBatchSQLProjection: <EventType extends Event>(handle: (events: EventType[], context: SQLiteProjectionHandlerContext) => Promise<string[]> | string[], ...canHandle: CanHandle<EventType>) => SQLiteProjectionDefinition<EventType>;
-declare const sqliteRawSQLProjection: <EventType extends Event>(handle: (event: EventType, context: SQLiteProjectionHandlerContext) => Promise<string> | string, ...canHandle: CanHandle<EventType>) => SQLiteProjectionDefinition<EventType>;
+type SQLiteRawBatchSQLProjection<EventType extends Event> = {
+    evolve: (events: EventType[], context: SQLiteProjectionHandlerContext) => Promise<string[]> | string[];
+    canHandle: CanHandle<EventType>;
+    initSQL?: string;
+    init?: (context: SQLiteProjectionHandlerContext) => void | Promise<void>;
+};
+declare const sqliteRawBatchSQLProjection: <EventType extends Event>(options: SQLiteRawBatchSQLProjection<EventType>) => SQLiteProjectionDefinition<EventType>;
+type SQLiteRawSQLProjection<EventType extends Event> = {
+    evolve: (events: EventType, context: SQLiteProjectionHandlerContext) => Promise<string[]> | string[] | Promise<string> | string;
+    canHandle: CanHandle<EventType>;
+    initSQL?: string;
+    init?: (context: SQLiteProjectionHandlerContext) => void | Promise<void>;
+};
+declare const sqliteRawSQLProjection: <EventType extends Event>(options: SQLiteRawSQLProjection<EventType>) => SQLiteProjectionDefinition<EventType>;
 
 type SQLiteProjectionSpecEvent<EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = EventType & {
     metadata?: Partial<EventMetaDataType>;
@@ -153,7 +201,8 @@ type SQLiteProjectionAssert = (options: {
     connection: SQLiteConnection;
 }) => Promise<void | boolean>;
 type SQLiteProjectionSpecOptions<EventType extends Event> = {
-    connection: SQLiteConnection;
+    fileName?: string;
+    connection?: SQLiteConnection;
     projection: SQLiteProjectionDefinition<EventType>;
 };
 type SQLiteProjectionSpec<EventType extends Event> = (givenEvents: SQLiteProjectionSpecEvent<EventType>[]) => {
@@ -252,7 +301,7 @@ declare const streamsTableSQL: string;
 declare const messagesTableSQL: string;
 declare const subscriptionsTableSQL: string;
 declare const schemaSQL: string[];
-declare const createEventStoreSchema: (db: SQLiteConnection) => Promise<void>;
+declare const createEventStoreSchema: (connection: SQLiteConnection, hooks?: SQLiteEventStoreOptions["hooks"]) => Promise<void>;
 
 declare const emmettPrefix = "emt";
 declare const globalTag = "global";
@@ -286,4 +335,4 @@ declare const subscriptionsTable: {
     name: string;
 };
 
-export { type AppendEventResult, type EventHandler, InMemorySQLiteDatabase, InMemorySharedCacheSQLiteDatabase, type Parameters$1 as Parameters, type ReadLastMessageGlobalPositionResult, type ReadMessagesBatchOptions, type ReadMessagesBatchResult, type ReadProcessorCheckpointResult, type SQLiteConnection, type SQLiteError, type SQLiteEventStore, SQLiteEventStoreDefaultStreamVersion, type SQLiteEventStoreOptions, type SQLiteProjectionAssert, type SQLiteProjectionDefinition, type SQLiteProjectionHandler, type SQLiteProjectionHandlerContext, type SQLiteProjectionHandlerOptions, SQLiteProjectionSpec, type SQLiteProjectionSpecEvent, type SQLiteProjectionSpecOptions, type SQLiteProjectionSpecWhenOptions, type SQLiteReadEvent, type SQLiteReadEventMetadata, type StoreLastProcessedProcessorPositionResult, appendToStream, assertSQLQueryResultMatches, createEventStoreSchema, defaultTag, emmettPrefix, eventInStream, eventsInStream, expectSQL, getSQLiteEventStore, globalNames, globalTag, handleProjections, isSQLiteError, messagesTable, messagesTableSQL, newEventsInStream, readLastMessageGlobalPosition, readMessagesBatch, readProcessorCheckpoint, readStream, schemaSQL, sql, sqliteConnection, sqliteProjection, sqliteRawBatchSQLProjection, sqliteRawSQLProjection, storeProcessorCheckpoint, streamsTable, streamsTableSQL, subscriptionsTable, subscriptionsTableSQL };
+export { type AppendEventResult, type EventHandler, InMemorySQLiteDatabase, InMemorySharedCacheSQLiteDatabase, type Parameters$1 as Parameters, type ReadLastMessageGlobalPositionResult, type ReadMessagesBatchOptions, type ReadMessagesBatchResult, type ReadProcessorCheckpointResult, type SQLiteConnection, type SQLiteError, type SQLiteEventStore, type SQLiteEventStoreConnectionOptions, SQLiteEventStoreDefaultStreamVersion, type SQLiteEventStoreOptions, type SQLiteProjectionAssert, type SQLiteProjectionDefinition, type SQLiteProjectionHandler, type SQLiteProjectionHandlerContext, type SQLiteProjectionHandlerOptions, SQLiteProjectionSpec, type SQLiteProjectionSpecEvent, type SQLiteProjectionSpecOptions, type SQLiteProjectionSpecWhenOptions, type SQLiteRawBatchSQLProjection, type SQLiteRawSQLProjection, type SQLiteReadEvent, type SQLiteReadEventMetadata, type StoreLastProcessedProcessorPositionResult, appendToStream, assertSQLQueryResultMatches, createEventStoreSchema, defaultTag, emmettPrefix, eventInStream, eventsInStream, expectSQL, getSQLiteEventStore, globalNames, globalTag, handleProjections, isSQLiteError, messagesTable, messagesTableSQL, newEventsInStream, readLastMessageGlobalPosition, readMessagesBatch, readProcessorCheckpoint, readStream, schemaSQL, sql, sqliteConnection, sqliteProjection, sqliteRawBatchSQLProjection, sqliteRawSQLProjection, storeProcessorCheckpoint, streamsTable, streamsTableSQL, subscriptionsTable, subscriptionsTableSQL };

package/dist/index.js

@@ -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
 import { v4 as uuid5 } from "uuid";
 
+// src/connection/sqliteConnectionPool.ts
+var SQLiteConnectionPool = (options) => {
+  const fileName = options.fileName ?? InMemorySQLiteDatabase;
+  const isInMemory = fileName === InMemorySQLiteDatabase || fileName === InMemorySharedCacheSQLiteDatabase;
+  const singletonConnection = options.connectionOptions?.connection ?? (isInMemory ? sqliteConnection({
+    fileName
+  }) : null);
+  const isAmbientConnection = options.connectionOptions?.singleton === true && options.connectionOptions?.connection !== void 0;
+  const createConnection = () => {
+    return singletonConnection ?? sqliteConnection({
+      fileName
+    });
+  };
+  const closeConnection = (connection) => {
+    if (isInMemory || isAmbientConnection) {
+      return;
+    }
+    connection.close();
+  };
+  const withConnection = async (handler) => {
+    const connection = 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 (hooks?.onBeforeSchemaCreated) {
+      await hooks.onBeforeSchemaCreated({ connection });
+    }
+    for (const sql2 of schemaSQL) {
+      await connection.command(sql2);
+    }
+  });
+  if (hooks?.onAfterSchemaCreated) {
+    await hooks.onAfterSchemaCreated();
   }
 };
 
@@ -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 readLastMessageGlobalPosition(connection)).currentGlobalPosition ?? 0n : options.startFrom.globalPosition;
+    const after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? (await pool.withConnection(
+      async (connection) => readLastMessageGlobalPosition(connection)
+    )).currentGlobalPosition ?? 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") {
@@ -1196,8 +1263,8 @@ var sqliteEventStoreConsumer = (options) => {
   const processors = options.processors ?? [];
   let start;
   let currentMessagePuller;
-  const connection = options.connection ?? sqliteConnection({ fileName: options.fileName });
-  const eachBatch = async (messagesBatch) => {
+  const pool = options.pool ?? SQLiteConnectionPool(options);
+  const eachBatch = (messagesBatch) => pool.withConnection(async (connection) => {
     const activeProcessors = processors.filter((s) => s.isActive);
     if (activeProcessors.length === 0)
       return {
@@ -1217,9 +1284,9 @@ var sqliteEventStoreConsumer = (options) => {
     ) ? void 0 : {
       type: "STOP"
     };
-  };
+  });
   const messagePooler = currentMessagePuller = sqliteEventStoreMessageBatchPuller({
-    connection,
+    pool,
     eachBatch,
     batchSize: pulling?.batchSize ?? DefaultSQLiteEventStoreProcessorBatchSize,
     pullingFrequencyInMs: pulling?.pullingFrequencyInMs ?? DefaultSQLiteEventStoreProcessorPullingFrequencyInMs
@@ -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,51 +1341,40 @@ var sqliteEventStoreConsumer = (options) => {
 // src/eventStore/SQLiteEventStore.ts
 var SQLiteEventStoreDefaultStreamVersion = 0n;
 var getSQLiteEventStore = (options) => {
-  let schemaMigrated = false;
   let autoGenerateSchema = false;
-  let database;
   const fileName = options.fileName ?? InMemorySQLiteDatabase;
-  const isInMemory = fileName === InMemorySQLiteDatabase || fileName === InMemorySharedCacheSQLiteDatabase;
+  const pool = options.pool ?? SQLiteConnectionPool(options);
+  let migrateSchema = void 0;
   const inlineProjections = (options.projections ?? []).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
   const onBeforeCommitHook = options.hooks?.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 withConnection = async (handler) => pool.withConnection(async (database) => {
+    await ensureSchemaExists(database);
+    return await handler(database);
+  });
   if (options) {
     autoGenerateSchema = options.schema?.autoMigration === void 0 || options.schema?.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 (options.hooks?.onBeforeSchemaCreated) {
+            await options.hooks.onBeforeSchemaCreated(context);
+          }
+        },
+        onAfterSchemaCreated: options.hooks?.onAfterSchemaCreated
+      });
     }
-    return Promise.resolve();
+    return migrateSchema;
+  };
+  const ensureSchemaExists = (connection) => {
+    if (!autoGenerateSchema) return Promise.resolve();
+    return migrate(connection);
   };
   return {
     async aggregateStream(streamName, options2) {
@@ -1326,9 +1384,6 @@ var getSQLiteEventStore = (options) => {
       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(
@@ -1386,8 +1438,13 @@ var getSQLiteEventStore = (options) => {
     consumer: (options2) => sqliteEventStoreConsumer({
       ...options2 ?? {},
       fileName,
-      connection: database ?? void 0
-    })
+      pool
+    }),
+    schema: {
+      sql: () => schemaSQL.join(""),
+      print: () => console.log(schemaSQL.join("")),
+      migrate: () => pool.withConnection(migrate)
+    }
   };
 };
 
@@ -1395,8 +1452,11 @@ var getSQLiteEventStore = (options) => {
 var SQLiteProjectionSpec = {
   for: (options) => {
     {
-      const connection = options.connection;
+      const connection = options.connection ?? sqliteConnection({
+        fileName: options.fileName ?? InMemorySQLiteDatabase
+      });
       const projection2 = options.projection;
+      let wasInitialized = false;
       return (givenEvents) => {
         return {
           when: (events, options2) => {
@@ -1423,6 +1483,10 @@ var SQLiteProjectionSpec = {
                   }
                 });
               }
+              if (!wasInitialized && projection2.init) {
+                await projection2.init({ connection: connection2 });
+                wasInitialized = true;
+              }
               await connection2.withTransaction(
                 () => handleProjections({
                   events: allEvents,