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

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-BZi2wy1K.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-BZi2wy1K.js';
 import '@event-driven-io/dumbo';
 import '@event-driven-io/dumbo/sqlite';
 import '@event-driven-io/emmett';

package/dist/index.cjs

@@ -1,4 +1,131 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// ../emmett/dist/chunk-AZDDB5SF.js
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/eventStore/projections/pongo/pongoProjections.ts
+
+
+var _pongo = require('@event-driven-io/pongo');
+var pongoProjection = ({
+  name,
+  kind,
+  version,
+  truncate,
+  handle,
+  canHandle,
+  eventsOptions
+}) => sqliteProjection({
+  name,
+  version,
+  kind: _nullishCoalesce(kind, () => ( "emt:projections:postgresql:pongo:generic")),
+  canHandle,
+  eventsOptions,
+  handle: async (events, context) => {
+    const { connection } = context;
+    const driver = await pongoDriverRegistry.tryResolve(
+      context.driverType
+    );
+    const pongo = _pongo.pongoClient.call(void 0, {
+      driver,
+      connectionOptions: { connection }
+    });
+    try {
+      await handle(events, {
+        ...context,
+        pongo
+      });
+    } finally {
+      await pongo.close();
+    }
+  },
+  truncate: truncate ? async (context) => {
+    const { connection } = context;
+    const driver = await pongoDriverRegistry.tryResolve(
+      context.driverType
+    );
+    const pongo = _pongo.pongoClient.call(void 0, {
+      driver,
+      connectionOptions: { connection }
+    });
+    try {
+      await truncate({
+        ...context,
+        pongo
+      });
+    } finally {
+      await pongo.close();
+    }
+  } : void 0
+});
+var pongoMultiStreamProjection = (options) => {
+  const { collectionName, getDocumentId, canHandle } = options;
+  const collectionNameWithVersion = options.version && options.version > 0 ? `${collectionName}_v${options.version}` : collectionName;
+  return pongoProjection({
+    name: collectionNameWithVersion,
+    version: options.version,
+    kind: _nullishCoalesce(options.kind, () => ( "emt:projections:postgresql:pongo:multi_stream")),
+    eventsOptions: options.eventsOptions,
+    handle: async (events, { pongo }) => {
+      const collection = pongo.db().collection(
+        collectionNameWithVersion,
+        options.collectionOptions
+      );
+      for (const event of events) {
+        await collection.handle(getDocumentId(event), async (document) => {
+          return "initialState" in options ? await options.evolve(
+            _nullishCoalesce(document, () => ( options.initialState())),
+            event
+          ) : await options.evolve(
+            document,
+            event
+          );
+        });
+      }
+    },
+    canHandle,
+    truncate: async (context) => {
+      const { connection } = context;
+      const driver = await pongoDriverRegistry.tryResolve(
+        context.driverType
+      );
+      const pongo = _pongo.pongoClient.call(void 0, {
+        driver,
+        connectionOptions: { connection }
+      });
+      try {
+        await pongo.db().collection(
+          collectionNameWithVersion,
+          options.collectionOptions
+        ).deleteMany();
+      } finally {
+        await pongo.close();
+      }
+    },
+    init: async (context) => {
+      const { connection } = context;
+      const driver = await pongoDriverRegistry.tryResolve(
+        context.driverType
+      );
+      const pongo = _pongo.pongoClient.call(void 0, {
+        connectionOptions: { connection },
+        driver
+      });
+      try {
+        await pongo.db().collection(
+          collectionNameWithVersion,
+          options.collectionOptions
+        ).schema.migrate();
+      } finally {
+        await pongo.close();
+      }
+    }
+  });
+};
+var pongoSingleStreamProjection = (options) => {
+  return pongoMultiStreamProjection({
+    ...options,
+    kind: "emt:projections:postgresql:pongo:single_stream",
+    getDocumentId: _nullishCoalesce(options.getDocumentId, () => ( ((event) => event.metadata.streamName)))
+  });
+};
+
+// ../emmett/dist/chunk-AZDDB5SF.js
 var isNumber = (val) => typeof val === "number" && val === val;
 var isString = (val) => typeof val === "string";
 var isErrorConstructor = (expect) => {
@@ -49,6 +176,7 @@ var ConcurrencyError = class _ConcurrencyError extends EmmettError {
 // ../emmett/dist/index.js
 var _uuid = require('uuid');
 
+
 var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
 
 
@@ -559,6 +687,15 @@ var isSubset = (superObj, subObj) => {
 var assertFails = (message2) => {
   throw new AssertionError(_nullishCoalesce(message2, () => ( "That should not ever happened, right?")));
 };
+var assertDeepEqual = (actual, expected, message2) => {
+  if (!deepEquals(actual, expected))
+    throw new AssertionError(
+      _nullishCoalesce(message2, () => ( `subObj:
+${JSONParser.stringify(expected)}
+is not equal to
+${JSONParser.stringify(actual)}`))
+    );
+};
 function assertTrue(condition, message2) {
   if (condition !== true)
     throw new AssertionError(_nullishCoalesce(message2, () => ( `Condition is false`)));
@@ -580,6 +717,13 @@ function assertNotEqual(obj, other, message2) {
       _nullishCoalesce(message2, () => ( `Objects are equal: ${JSONParser.stringify(obj)}`))
     );
 }
+function assertIsNotNull(result) {
+  assertNotEqual(result, null);
+  assertOk(result);
+}
+function assertIsNull(result) {
+  assertEqual(result, null);
+}
 var assertThatArray = (array) => {
   return {
     isEmpty: () => assertEqual(
@@ -923,6 +1067,143 @@ var workflowProcessor = (options) => {
   });
 };
 
+// src/eventStore/projections/pongo/pongoProjectionSpec.ts
+
+
+
+var withCollection = async (handle, options) => {
+  const { connection, inDatabase, inCollection } = options;
+  const driver = await pongoDriverRegistry.tryResolve(
+    connection.driverType
+  );
+  const pongo = _pongo.pongoClient.call(void 0, {
+    connectionOptions: { connection },
+    driver
+  });
+  try {
+    const collection = pongo.db(inDatabase).collection(inCollection);
+    return handle(collection);
+  } finally {
+    await pongo.close();
+  }
+};
+var withoutIdAndVersion = (doc) => {
+  const { _id, _version, ...without } = doc;
+  return without;
+};
+var assertDocumentsEqual = (actual, expected) => {
+  if ("_id" in expected)
+    assertEqual(
+      expected._id,
+      actual._id,
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `Document ids are not matching! Expected: ${expected._id}, Actual: ${actual._id}`
+    );
+  return assertDeepEqual(
+    withoutIdAndVersion(actual),
+    withoutIdAndVersion(expected)
+  );
+};
+var documentExists = (document, options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.findOne(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertIsNotNull(result);
+    assertDocumentsEqual(result, document);
+  },
+  { ...options, ...assertOptions }
+);
+var documentsAreTheSame = (documents, options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.find(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertEqual(
+      documents.length,
+      result.length,
+      "Different Documents Count than expected"
+    );
+    for (let i = 0; i < documents.length; i++) {
+      assertThatArray(result).contains(documents[i]);
+    }
+  },
+  { ...options, ...assertOptions }
+);
+var documentsMatchingHaveCount = (expectedCount, options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.find(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertEqual(
+      expectedCount,
+      result.length,
+      "Different Documents Count than expected"
+    );
+  },
+  { ...options, ...assertOptions }
+);
+var documentMatchingExists = (options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.find(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertThatArray(result).isNotEmpty();
+  },
+  { ...options, ...assertOptions }
+);
+var documentDoesNotExist = (options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.findOne(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertIsNull(result);
+  },
+  { ...options, ...assertOptions }
+);
+var expectPongoDocuments = {
+  fromCollection: (collectionName) => {
+    return {
+      withId: (id) => {
+        return {
+          toBeEqual: (document) => documentExists(document, {
+            withId: id,
+            inCollection: collectionName
+          }),
+          toExist: () => documentMatchingExists({
+            withId: id,
+            inCollection: collectionName
+          }),
+          notToExist: () => documentDoesNotExist({
+            withId: id,
+            inCollection: collectionName
+          })
+        };
+      },
+      matching: (filter) => {
+        return {
+          toBeTheSame: (documents) => documentsAreTheSame(documents, {
+            matchingFilter: filter,
+            inCollection: collectionName
+          }),
+          toHaveCount: (expectedCount) => documentsMatchingHaveCount(expectedCount, {
+            matchingFilter: filter,
+            inCollection: collectionName
+          }),
+          toExist: () => documentMatchingExists({
+            matchingFilter: filter,
+            inCollection: collectionName
+          }),
+          notToExist: () => documentDoesNotExist({
+            matchingFilter: filter,
+            inCollection: collectionName
+          })
+        };
+      }
+    };
+  }
+};
+
 // src/eventStore/projections/sqliteProjection.ts
 var handleProjections = async (options) => {
   const {
@@ -1540,8 +1821,6 @@ var readProcessorCheckpoint = async (execute, options) => {
 // src/eventStore/SQLiteEventStore.ts
 
 
-
-
 // src/eventStore/consumers/messageBatchProcessing/index.ts
 var DefaultSQLiteEventStoreProcessorBatchSize = 100;
 var DefaultSQLiteEventStoreProcessorPullingFrequencyInMs = 50;
@@ -1927,10 +2206,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 +2236,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 +2270,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 +2312,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(""),
@@ -2305,5 +2609,14 @@ var createEventStoreSchema = async (pool, hooks) => {
 
 
 
-exports.SQLiteEventStoreDefaultStreamVersion = SQLiteEventStoreDefaultStreamVersion; exports.SQLiteProjectionSpec = SQLiteProjectionSpec; exports.appendToStream = appendToStream; exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches; exports.createEventStoreSchema = createEventStoreSchema; exports.defaultTag = defaultTag2; exports.emmettPrefix = emmettPrefix2; exports.eventInStream = eventInStream; exports.eventsInStream = eventsInStream; exports.expectSQL = expectSQL; exports.getSQLiteEventStore = getSQLiteEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.messagesTable = messagesTable; exports.messagesTableSQL = messagesTableSQL; exports.migration_0_42_0_FromSubscriptionsToProcessors = migration_0_42_0_FromSubscriptionsToProcessors; exports.migration_0_42_0_SQLs = migration_0_42_0_SQLs; exports.newEventsInStream = newEventsInStream; exports.processorsTable = processorsTable; exports.processorsTableSQL = processorsTableSQL; exports.projectionsTable = projectionsTable; exports.projectionsTableSQL = projectionsTableSQL; exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition; exports.readMessagesBatch = readMessagesBatch; exports.readProcessorCheckpoint = readProcessorCheckpoint; exports.readStream = readStream; exports.schemaSQL = schemaSQL; exports.schema_0_41_0 = schema_0_41_0; exports.schema_0_42_0 = schema_0_42_0; exports.sqliteProjection = sqliteProjection; exports.sqliteRawBatchSQLProjection = sqliteRawBatchSQLProjection; exports.sqliteRawSQLProjection = sqliteRawSQLProjection; exports.storeProcessorCheckpoint = storeProcessorCheckpoint; exports.streamExists = streamExists; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.unknownTag = unknownTag2;
+
+
+
+
+
+
+
+
+
+exports.SQLiteEventStoreDefaultStreamVersion = SQLiteEventStoreDefaultStreamVersion; exports.SQLiteProjectionSpec = SQLiteProjectionSpec; exports.appendToStream = appendToStream; exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches; exports.createEventStoreSchema = createEventStoreSchema; exports.defaultTag = defaultTag2; exports.documentDoesNotExist = documentDoesNotExist; exports.documentExists = documentExists; exports.documentMatchingExists = documentMatchingExists; exports.documentsAreTheSame = documentsAreTheSame; exports.documentsMatchingHaveCount = documentsMatchingHaveCount; exports.emmettPrefix = emmettPrefix2; exports.eventInStream = eventInStream; exports.eventsInStream = eventsInStream; exports.expectPongoDocuments = expectPongoDocuments; exports.expectSQL = expectSQL; exports.getSQLiteEventStore = getSQLiteEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.messagesTable = messagesTable; exports.messagesTableSQL = messagesTableSQL; exports.migration_0_42_0_FromSubscriptionsToProcessors = migration_0_42_0_FromSubscriptionsToProcessors; exports.migration_0_42_0_SQLs = migration_0_42_0_SQLs; exports.newEventsInStream = newEventsInStream; exports.pongoMultiStreamProjection = pongoMultiStreamProjection; exports.pongoProjection = pongoProjection; exports.pongoSingleStreamProjection = pongoSingleStreamProjection; exports.processorsTable = processorsTable; exports.processorsTableSQL = processorsTableSQL; exports.projectionsTable = projectionsTable; exports.projectionsTableSQL = projectionsTableSQL; exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition; exports.readMessagesBatch = readMessagesBatch; exports.readProcessorCheckpoint = readProcessorCheckpoint; exports.readStream = readStream; exports.schemaSQL = schemaSQL; exports.schema_0_41_0 = schema_0_41_0; exports.schema_0_42_0 = schema_0_42_0; exports.sqliteProjection = sqliteProjection; exports.sqliteRawBatchSQLProjection = sqliteRawBatchSQLProjection; exports.sqliteRawSQLProjection = sqliteRawSQLProjection; exports.storeProcessorCheckpoint = storeProcessorCheckpoint; exports.streamExists = streamExists; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.unknownTag = unknownTag2;
 //# sourceMappingURL=index.cjs.map