@event-driven-io/emmett-sqlite 0.43.0-beta.5 → 0.43.0-beta.6

package/dist/cloudflare.d.cts

@@ -1,6 +1,6 @@
 import { D1Database } from '@cloudflare/workers-types';
 import { d1DumboDriver, D1PoolOptions } from '@event-driven-io/dumbo/cloudflare';
-import { E as EventStoreDriver, S as SQLiteEventStoreOptions } from './sqliteProjection-DBJa19a5.cjs';
+import { E as EventStoreDriver, S as SQLiteEventStoreOptions } from './sqliteProjection-D6WKeuhb.cjs';
 import '@event-driven-io/dumbo';
 import '@event-driven-io/dumbo/sqlite';
 import '@event-driven-io/emmett';

package/dist/cloudflare.d.ts

@@ -1,6 +1,6 @@
 import { D1Database } from '@cloudflare/workers-types';
 import { d1DumboDriver, D1PoolOptions } from '@event-driven-io/dumbo/cloudflare';
-import { E as EventStoreDriver, S as SQLiteEventStoreOptions } from './sqliteProjection-DBJa19a5.js';
+import { E as EventStoreDriver, S as SQLiteEventStoreOptions } from './sqliteProjection-D6WKeuhb.js';
 import '@event-driven-io/dumbo';
 import '@event-driven-io/dumbo/sqlite';
 import '@event-driven-io/emmett';

package/dist/index.cjs

@@ -49,6 +49,7 @@ var ConcurrencyError = class _ConcurrencyError extends EmmettError {
 // ../emmett/dist/index.js
 var _uuid = require('uuid');
 
+
 var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
 
 
@@ -1540,8 +1541,6 @@ var readProcessorCheckpoint = async (execute, options) => {
 // src/eventStore/SQLiteEventStore.ts
 
 
-
-
 // src/eventStore/consumers/messageBatchProcessing/index.ts
 var DefaultSQLiteEventStoreProcessorBatchSize = 100;
 var DefaultSQLiteEventStoreProcessorPullingFrequencyInMs = 50;
@@ -1927,10 +1926,6 @@ var getSQLiteEventStore = (options) => {
   let migrateSchema = void 0;
   const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
   const onBeforeCommitHook = _optionalChain([options, 'access', _98 => _98.hooks, 'optionalAccess', _99 => _99.onBeforeCommit]);
-  const withConnection = (handler, options2) => pool.withConnection(async (connection) => {
-    await ensureSchemaExists(connection);
-    return await handler(connection);
-  }, options2);
   if (options) {
     autoGenerateSchema = _optionalChain([options, 'access', _100 => _100.schema, 'optionalAccess', _101 => _101.autoMigration]) === void 0 || _optionalChain([options, 'access', _102 => _102.schema, 'optionalAccess', _103 => _103.autoMigration]) !== "None";
   }
@@ -1961,21 +1956,23 @@ var getSQLiteEventStore = (options) => {
     }
     return migrateSchema;
   };
-  const ensureSchemaExists = (connection) => {
+  const ensureSchemaExists = () => {
     if (!autoGenerateSchema) return Promise.resolve();
-    return migrate(connection);
+    return pool.withConnection((connection) => migrate(connection));
   };
   return {
     async aggregateStream(streamName, options2) {
+      await ensureSchemaExists();
       const { evolve, initialState, read } = options2;
       const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _108 => _108.expectedStreamVersion]);
       let state = initialState();
       if (typeof streamName !== "string") {
         throw new Error("Stream name is not string");
       }
-      const result = await withConnection(
-        ({ execute }) => readStream(execute, streamName, read),
-        { readonly: true }
+      const result = await readStream(
+        pool.execute,
+        streamName,
+        read
       );
       const currentStreamVersion = result.currentStreamVersion;
       assertExpectedVersionMatchesCurrent(
@@ -1993,14 +1990,19 @@ var getSQLiteEventStore = (options) => {
         streamExists: result.streamExists
       };
     },
-    readStream: async (streamName, options2) => withConnection(
-      ({ execute }) => readStream(execute, streamName, options2),
-      { readonly: true }
-    ),
+    readStream: async (streamName, options2) => {
+      await ensureSchemaExists();
+      return readStream(
+        pool.execute,
+        streamName,
+        options2
+      );
+    },
     appendToStream: async (streamName, events, appendOptions) => {
+      await ensureSchemaExists();
       const [firstPart, ...rest] = streamName.split("-");
       const streamType = firstPart && rest.length > 0 ? firstPart : unknownTag2;
-      const appendResult = await withConnection(
+      const appendResult = await pool.withConnection(
         (connection) => appendToStream(connection, streamName, streamType, events, {
           ...appendOptions,
           onBeforeCommit: async (messages, context) => {
@@ -2030,17 +2032,39 @@ var getSQLiteEventStore = (options) => {
         createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
       };
     },
-    streamExists(streamName, options2) {
-      return withConnection(
-        ({ execute }) => streamExists(execute, streamName, options2),
-        { readonly: true }
-      );
+    async streamExists(streamName, options2) {
+      await ensureSchemaExists();
+      return streamExists(pool.execute, streamName, options2);
     },
     consumer: (consumerOptions) => sqliteEventStoreConsumer({
       ..._nullishCoalesce(options, () => ( {})),
       ..._nullishCoalesce(consumerOptions, () => ( {})),
       pool
     }),
+    async withSession(callback) {
+      return await pool.withConnection(async (connection) => {
+        const sessionStore = getSQLiteEventStore({
+          ...options,
+          pool: _dumbo.dumbo.call(void 0, {
+            ...options.driver.mapToDumboOptions(options),
+            connection
+          }),
+          transactionOptions: {
+            allowNestedTransactions: true,
+            mode: "session_based"
+          },
+          schema: {
+            ...options.schema,
+            autoMigration: "None"
+          }
+        });
+        await ensureSchemaExists();
+        return callback({
+          eventStore: sessionStore,
+          close: () => Promise.resolve()
+        });
+      });
+    },
     close: () => pool.close(),
     schema: {
       sql: () => schemaSQL.join(""),