@wataruoguchi/emmett-event-store-kysely 1.1.2 → 2.0.0

package/dist/event-store/kysely-event-store.js

@@ -0,0 +1,256 @@
+// biome-ignore assist/source/organizeImports: retain import order similar to app code
+import { assertExpectedVersionMatchesCurrent, } from "@event-driven-io/emmett";
+import { DEFAULT_PARTITION, PostgreSQLEventStoreDefaultStreamVersion, } from "../types.js";
+export const defaultKyselyOptions = {
+    schema: {
+        autoMigration: "CreateOrUpdate",
+    },
+};
+export const getKyselyEventStore = (deps) => {
+    const { db, logger } = deps;
+    const eventStore = {
+        /**
+         * @description We do not use schema management in this package.
+         */
+        schema: {
+            sql: () => "",
+            print: () => console.log(""),
+            migrate: async () => Promise.resolve(),
+        },
+        /**
+         * @description We do not use session management in this package.
+         */
+        async withSession(callback) {
+            return await callback({
+                eventStore,
+                close: () => Promise.resolve(),
+            });
+        },
+        async aggregateStream(streamName, options) {
+            const { evolve, initialState, read } = options;
+            logger.info({ streamName, options }, "aggregateStream");
+            const expectedStreamVersion = read?.expectedStreamVersion;
+            const result = await eventStore.readStream(streamName, read);
+            assertExpectedVersionMatchesCurrent(result.currentStreamVersion, expectedStreamVersion, PostgreSQLEventStoreDefaultStreamVersion);
+            const state = result.events.reduce((state, event) => (event ? evolve(state, event) : state), initialState());
+            return {
+                state,
+                currentStreamVersion: result.currentStreamVersion,
+                streamExists: result.streamExists,
+            };
+        },
+        async readStream(streamName, options) {
+            const partition = getPartition(options);
+            logger.info({ streamName, options, partition }, "readStream");
+            const { currentStreamVersion, streamExists } = await fetchStreamInfo(db, streamName, partition);
+            const range = parseRangeOptions(options);
+            const rows = await buildEventsQuery({ db, logger }, streamName, partition, range).execute();
+            const events = rows.map((row) => mapRowToEvent(row, streamName));
+            return {
+                events,
+                currentStreamVersion,
+                streamExists,
+            };
+        },
+        async appendToStream(streamName, events, options) {
+            const streamType = getStreamType(options);
+            const partition = getPartition(options);
+            const expected = options?.expectedStreamVersion;
+            logger.info({ streamName, events, options, partition }, "appendToStream");
+            ensureEventsNotEmpty(events, expected);
+            const result = await db
+                .transaction()
+                .execute(async (trx) => {
+                const { currentStreamVersion, streamExists } = await fetchStreamInfo(trx, streamName, partition);
+                assertExpectedVersion(expected, currentStreamVersion, streamExists);
+                const basePos = currentStreamVersion;
+                const nextStreamPosition = computeNextStreamPosition(basePos, events.length);
+                await upsertStreamRow(trx, streamName, partition, streamType, basePos, nextStreamPosition, expected, streamExists);
+                const messagesToInsert = buildMessagesToInsert(events, basePos, streamName, partition);
+                const lastEventGlobalPosition = await insertMessagesAndGetLastGlobalPosition(trx, messagesToInsert);
+                return {
+                    nextExpectedStreamVersion: nextStreamPosition,
+                    lastEventGlobalPosition,
+                    createdNewStream: !streamExists,
+                };
+            });
+            return result;
+        },
+        close: async () => {
+            // Kysely doesn't require explicit closing for most cases
+            // but we can add cleanup logic here if needed
+            await Promise.resolve();
+        },
+    };
+    return eventStore;
+};
+// Helper functions (consolidated from the optimized implementation)
+function getStreamType(options) {
+    return options?.streamType ?? "unknown";
+}
+function getPartition(options) {
+    return options?.partition ?? DEFAULT_PARTITION;
+}
+function ensureEventsNotEmpty(events, _expected) {
+    if (events.length === 0) {
+        throw new Error("Cannot append empty events array");
+    }
+}
+function assertExpectedVersion(expected, currentPos, streamExistsNow) {
+    if (expected === "STREAM_EXISTS" && !streamExistsNow) {
+        throw new Error("Stream does not exist but expected to exist");
+    }
+    if (expected === "STREAM_DOES_NOT_EXIST" && streamExistsNow) {
+        throw new Error("Stream exists but expected not to exist");
+    }
+    if (typeof expected === "bigint" && expected !== currentPos) {
+        throw new Error(`Expected version ${expected} but current is ${currentPos}`);
+    }
+}
+function computeNextStreamPosition(basePos, eventCount) {
+    return basePos + BigInt(eventCount);
+}
+async function upsertStreamRow(executor, streamId, partition, streamType, basePos, nextStreamPosition, expected, streamExistsNow) {
+    if (!streamExistsNow) {
+        await executor
+            .insertInto("streams")
+            .values({
+            stream_id: streamId,
+            stream_position: nextStreamPosition,
+            partition,
+            stream_type: streamType,
+            stream_metadata: {},
+            is_archived: false,
+        })
+            .execute();
+        return;
+    }
+    if (typeof expected === "bigint") {
+        const updatedRow = await executor
+            .updateTable("streams")
+            .set({ stream_position: nextStreamPosition })
+            .where("stream_id", "=", streamId)
+            .where("partition", "=", partition)
+            .where("is_archived", "=", false)
+            .where("stream_position", "=", basePos)
+            .returning("stream_position")
+            .executeTakeFirst();
+        if (!updatedRow) {
+            throw new Error(`Expected version ${expected} but current is ${basePos}`);
+        }
+        return;
+    }
+    await executor
+        .updateTable("streams")
+        .set({ stream_position: nextStreamPosition })
+        .where("stream_id", "=", streamId)
+        .where("partition", "=", partition)
+        .where("is_archived", "=", false)
+        .execute();
+}
+function buildMessagesToInsert(events, basePos, streamId, partition) {
+    return events.map((e, index) => {
+        const messageId = crypto.randomUUID();
+        const streamPosition = basePos + BigInt(index + 1);
+        const rawMeta = "metadata" in e ? e.metadata : undefined;
+        const eventMeta = rawMeta && typeof rawMeta === "object" ? rawMeta : {};
+        const messageMetadata = {
+            messageId,
+            ...eventMeta,
+        };
+        return {
+            stream_id: streamId,
+            stream_position: streamPosition,
+            partition,
+            message_data: e.data,
+            message_metadata: messageMetadata,
+            message_schema_version: index.toString(),
+            message_type: e.type,
+            message_kind: "E",
+            message_id: messageId,
+            is_archived: false,
+            created: new Date(),
+        };
+    });
+}
+async function insertMessagesAndGetLastGlobalPosition(executor, messagesToInsert) {
+    const inserted = await executor
+        .insertInto("messages")
+        .values(messagesToInsert)
+        .returning("global_position")
+        .execute();
+    if (!inserted || (Array.isArray(inserted) && inserted.length === 0)) {
+        return 0n;
+    }
+    const globalPositions = inserted.map((r) => BigInt(String(r.global_position)));
+    return globalPositions[globalPositions.length - 1];
+}
+function parseRangeOptions(options) {
+    const from = options && typeof options === "object" && "from" in options
+        ? options.from
+        : undefined;
+    const to = options && typeof options === "object" && "to" in options
+        ? options.to
+        : undefined;
+    const maxCount = options && typeof options === "object" && "maxCount" in options
+        ? options.maxCount
+        : undefined;
+    return { from, to, maxCount };
+}
+function buildEventsQuery(deps, streamId, partition, range) {
+    const { db } = deps;
+    let q = db
+        .selectFrom("messages")
+        .select([
+        "message_type",
+        "message_data",
+        "message_metadata",
+        "stream_position",
+        "global_position",
+        "message_id",
+    ])
+        .where("stream_id", "=", streamId)
+        .where("partition", "=", partition)
+        .where("is_archived", "=", false)
+        .orderBy("stream_position");
+    if (range.from !== undefined) {
+        q = q.where("stream_position", ">=", range.from);
+    }
+    if (range.to !== undefined) {
+        q = q.where("stream_position", "<=", range.to);
+    }
+    if (range.maxCount !== undefined) {
+        q = q.limit(Number(range.maxCount));
+    }
+    return q;
+}
+function mapRowToEvent(row, streamId) {
+    const streamPosition = BigInt(String(row.stream_position));
+    const globalPosition = BigInt(String(row.global_position ?? 0));
+    const baseMetadata = (row.message_metadata ?? {});
+    return {
+        kind: "Event",
+        type: row.message_type,
+        data: row.message_data,
+        metadata: {
+            ...baseMetadata,
+            messageId: row.message_id,
+            streamId: streamId,
+            streamPosition: streamPosition,
+            globalPosition: globalPosition,
+        },
+    };
+}
+async function fetchStreamInfo(executor, streamId, partition) {
+    const streamRow = await executor
+        .selectFrom("streams")
+        .select(["stream_position"])
+        .where("stream_id", "=", streamId)
+        .where("partition", "=", partition)
+        .where("is_archived", "=", false)
+        .executeTakeFirst();
+    const currentStreamVersion = streamRow
+        ? BigInt(String(streamRow.stream_position))
+        : PostgreSQLEventStoreDefaultStreamVersion;
+    return { currentStreamVersion, streamExists: !!streamRow };
+}