@event-driven-io/emmett-postgresql 0.38.3 → 0.38.5

package/dist/index.cjs

@@ -84,24 +84,117 @@ var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends C
     Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
-var deepEquals = (left, right) => {
-  if (isEquatable(left)) {
-    return left.equals(right);
+var isPrimitive = (value) => {
+  const type = typeof value;
+  return value === null || value === void 0 || type === "boolean" || type === "number" || type === "string" || type === "symbol" || type === "bigint";
+};
+var compareArrays = (left, right) => {
+  if (left.length !== right.length) {
+    return false;
   }
-  if (Array.isArray(left)) {
-    return Array.isArray(right) && left.length === right.length && left.every((val, index) => deepEquals(val, right[index]));
+  for (let i = 0; i < left.length; i++) {
+    const leftHas = i in left;
+    const rightHas = i in right;
+    if (leftHas !== rightHas) return false;
+    if (leftHas && !deepEquals(left[i], right[i])) return false;
   }
-  if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) {
-    return left === right;
+  return true;
+};
+var compareDates = (left, right) => {
+  return left.getTime() === right.getTime();
+};
+var compareRegExps = (left, right) => {
+  return left.toString() === right.toString();
+};
+var compareErrors = (left, right) => {
+  if (left.message !== right.message || left.name !== right.name) {
+    return false;
+  }
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) return false;
+  const rightKeySet = new Set(rightKeys);
+  for (const key of leftKeys) {
+    if (!rightKeySet.has(key)) return false;
+    if (!deepEquals(left[key], right[key])) return false;
+  }
+  return true;
+};
+var compareMaps = (left, right) => {
+  if (left.size !== right.size) return false;
+  for (const [key, value] of left) {
+    if (isPrimitive(key)) {
+      if (!right.has(key) || !deepEquals(value, right.get(key))) {
+        return false;
+      }
+    } else {
+      let found = false;
+      for (const [rightKey, rightValue] of right) {
+        if (deepEquals(key, rightKey) && deepEquals(value, rightValue)) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) return false;
+    }
+  }
+  return true;
+};
+var compareSets = (left, right) => {
+  if (left.size !== right.size) return false;
+  for (const leftItem of left) {
+    if (isPrimitive(leftItem)) {
+      if (!right.has(leftItem)) return false;
+    } else {
+      let found = false;
+      for (const rightItem of right) {
+        if (deepEquals(leftItem, rightItem)) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) return false;
+    }
+  }
+  return true;
+};
+var compareArrayBuffers = (left, right) => {
+  if (left.byteLength !== right.byteLength) return false;
+  const leftView = new Uint8Array(left);
+  const rightView = new Uint8Array(right);
+  for (let i = 0; i < leftView.length; i++) {
+    if (leftView[i] !== rightView[i]) return false;
   }
-  if (Array.isArray(right)) return false;
+  return true;
+};
+var compareTypedArrays = (left, right) => {
+  if (left.constructor !== right.constructor) return false;
+  if (left.byteLength !== right.byteLength) return false;
+  const leftArray = new Uint8Array(
+    left.buffer,
+    left.byteOffset,
+    left.byteLength
+  );
+  const rightArray = new Uint8Array(
+    right.buffer,
+    right.byteOffset,
+    right.byteLength
+  );
+  for (let i = 0; i < leftArray.length; i++) {
+    if (leftArray[i] !== rightArray[i]) return false;
+  }
+  return true;
+};
+var compareObjects = (left, right) => {
   const keys1 = Object.keys(left);
   const keys2 = Object.keys(right);
-  if (keys1.length !== keys2.length || !keys1.every((key) => keys2.includes(key)))
+  if (keys1.length !== keys2.length) {
     return false;
-  for (const key in left) {
-    if (left[key] instanceof Function && right[key] instanceof Function)
+  }
+  for (const key of keys1) {
+    if (left[key] instanceof Function && right[key] instanceof Function) {
       continue;
+    }
     const isEqual = deepEquals(left[key], right[key]);
     if (!isEqual) {
       return false;
@@ -109,8 +202,88 @@ var deepEquals = (left, right) => {
   }
   return true;
 };
+var getType = (value) => {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const primitiveType = typeof value;
+  if (primitiveType !== "object") return primitiveType;
+  if (Array.isArray(value)) return "array";
+  if (value instanceof Boolean) return "boxed-boolean";
+  if (value instanceof Number) return "boxed-number";
+  if (value instanceof String) return "boxed-string";
+  if (value instanceof Date) return "date";
+  if (value instanceof RegExp) return "regexp";
+  if (value instanceof Error) return "error";
+  if (value instanceof Map) return "map";
+  if (value instanceof Set) return "set";
+  if (value instanceof ArrayBuffer) return "arraybuffer";
+  if (value instanceof DataView) return "dataview";
+  if (value instanceof WeakMap) return "weakmap";
+  if (value instanceof WeakSet) return "weakset";
+  if (ArrayBuffer.isView(value)) return "typedarray";
+  return "object";
+};
+var deepEquals = (left, right) => {
+  if (left === right) return true;
+  if (isEquatable(left)) {
+    return left.equals(right);
+  }
+  const leftType = getType(left);
+  const rightType = getType(right);
+  if (leftType !== rightType) return false;
+  switch (leftType) {
+    case "null":
+    case "undefined":
+    case "boolean":
+    case "number":
+    case "bigint":
+    case "string":
+    case "symbol":
+    case "function":
+      return left === right;
+    case "array":
+      return compareArrays(left, right);
+    case "date":
+      return compareDates(left, right);
+    case "regexp":
+      return compareRegExps(left, right);
+    case "error":
+      return compareErrors(left, right);
+    case "map":
+      return compareMaps(
+        left,
+        right
+      );
+    case "set":
+      return compareSets(left, right);
+    case "arraybuffer":
+      return compareArrayBuffers(left, right);
+    case "dataview":
+    case "weakmap":
+    case "weakset":
+      return false;
+    case "typedarray":
+      return compareTypedArrays(
+        left,
+        right
+      );
+    case "boxed-boolean":
+      return left.valueOf() === right.valueOf();
+    case "boxed-number":
+      return left.valueOf() === right.valueOf();
+    case "boxed-string":
+      return left.valueOf() === right.valueOf();
+    case "object":
+      return compareObjects(
+        left,
+        right
+      );
+    default:
+      return false;
+  }
+};
 var isEquatable = (left) => {
-  return left && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
+  return left !== null && left !== void 0 && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
 };
 var ParseError = class extends Error {
   constructor(text) {
@@ -804,9 +977,15 @@ var appendToStreamSQL = _dumbo.rawSql.call(void 0,
       v_transaction_id := pg_current_xact_id();
 
       IF v_expected_stream_position IS NULL THEN
-          SELECT COALESCE(max(stream_position), 0) INTO v_expected_stream_position
-          FROM ${streamsTable.name}
-          WHERE stream_id = v_stream_id AND partition = v_partition;
+          SELECT COALESCE(
+            (SELECT stream_position 
+            FROM ${streamsTable.name}
+            WHERE stream_id = v_stream_id 
+              AND partition = v_partition 
+              AND is_archived = FALSE
+            LIMIT 1), 
+            0
+        ) INTO v_expected_stream_position;
       END IF;
 
       v_next_stream_position := v_expected_stream_position + array_upper(v_messages_data, 1);
@@ -1060,9 +1239,12 @@ var streamsTableSQL = _dumbo.rawSql.call(void 0,
       stream_type       TEXT                      NOT NULL,
       stream_metadata   JSONB                     NOT NULL,
       is_archived       BOOLEAN                   NOT NULL DEFAULT FALSE,
-      PRIMARY KEY (stream_id, stream_position, partition, is_archived),
-      UNIQUE (stream_id, partition, is_archived)
-  ) PARTITION BY LIST (partition);`
+      PRIMARY KEY (stream_id, partition, is_archived)
+  ) PARTITION BY LIST (partition);
+   
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_streams_unique 
+  ON ${streamsTable.name}(stream_id, partition, is_archived) 
+  INCLUDE (stream_position);`
 );
 var messagesTableSQL = _dumbo.rawSql.call(void 0, 
   `
@@ -2120,12 +2302,16 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     ...options.connectionOptions ? options.connectionOptions : {}
   };
   const pool = "dumbo" in poolOptions ? poolOptions.dumbo : _dumbo.dumbo.call(void 0, poolOptions);
-  let migrateSchema;
+  let migrateSchema = void 0;
   const autoGenerateSchema = _optionalChain([options, 'access', _83 => _83.schema, 'optionalAccess', _84 => _84.autoMigration]) === void 0 || _optionalChain([options, 'access', _85 => _85.schema, 'optionalAccess', _86 => _86.autoMigration]) !== "None";
   const ensureSchemaExists = () => {
     if (!autoGenerateSchema) return Promise.resolve();
     if (!migrateSchema) {
-      migrateSchema = createEventStoreSchema(pool);
+      migrateSchema = createEventStoreSchema(pool).then(async () => {
+        if (_optionalChain([options, 'access', _87 => _87.hooks, 'optionalAccess', _88 => _88.onAfterSchemaCreated])) {
+          await options.hooks.onAfterSchemaCreated();
+        }
+      });
     }
     return migrateSchema;
   };
@@ -2151,7 +2337,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     },
     async aggregateStream(streamName, options2) {
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _87 => _87.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _89 => _89.expectedStreamVersion]);
       let state = initialState();
       const result = await this.readStream(streamName, options2.read);
       const currentStreamVersion = result.currentStreamVersion;
@@ -2192,7 +2378,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _88 => _88.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _90 => _90.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
@@ -2212,16 +2398,22 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
           ...options,
           connectionOptions: {
             connection
+          },
+          schema: {
+            ..._nullishCoalesce(options.schema, () => ( {})),
+            autoMigration: "None"
           }
         };
         const eventStore = getPostgreSQLEventStore(
           connectionString,
           storeOptions
         );
-        return callback({
-          eventStore,
-          close: () => Promise.resolve()
-        });
+        return ensureSchemaExists().then(
+          () => callback({
+            eventStore,
+            close: () => Promise.resolve()
+          })
+        );
       });
     }
   };