@wataruoguchi/emmett-event-store-kysely 1.1.1

package/dist/db-schema.d.ts

@@ -0,0 +1,34 @@
+export interface MessagesTable {
+    created: Date;
+    global_position: bigint | null;
+    is_archived: boolean;
+    message_data: unknown;
+    message_id: string;
+    message_kind: string;
+    message_metadata: unknown;
+    message_schema_version: string;
+    message_type: string;
+    partition: string;
+    stream_id: string;
+    stream_position: bigint;
+}
+export interface StreamsTable {
+    is_archived: boolean;
+    partition: string;
+    stream_id: string;
+    stream_metadata: unknown;
+    stream_position: bigint;
+    stream_type: string;
+}
+export interface SubscriptionsTable {
+    last_processed_position: bigint;
+    partition: string;
+    subscription_id: string;
+    version: number;
+}
+export interface EventStoreDBSchema {
+    messages: MessagesTable;
+    streams: StreamsTable;
+    subscriptions: SubscriptionsTable;
+}
+//# sourceMappingURL=db-schema.d.ts.map

package/dist/db-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-schema.d.ts","sourceRoot":"","sources":["../src/db-schema.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,IAAI,CAAC;IACd,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,WAAW,EAAE,OAAO,CAAC;IACrB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,OAAO,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,uBAAuB,EAAE,MAAM,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,aAAa,CAAC;IACxB,OAAO,EAAE,YAAY,CAAC;IACtB,aAAa,EAAE,kBAAkB,CAAC;CACnC"}

package/dist/db-schema.js

@@ -0,0 +1,3 @@
+// Use the example project's database schema which includes the event store tables
+// This makes the package compatible with any database that includes these tables
+export {};

package/dist/event-store/aggregate-stream.d.ts

@@ -0,0 +1,10 @@
+import { type AggregateStreamOptions, type AggregateStreamResult, type Event, type ReadEventMetadataWithGlobalPosition } from "@event-driven-io/emmett";
+import { type Dependencies } from "../types.js";
+import type { ReadStream } from "./read-stream.js";
+type PostgresReadEventMetadata = ReadEventMetadataWithGlobalPosition;
+export type AggregateStream = <State, EventType extends Event>(streamId: string, options: AggregateStreamOptions<State, EventType, PostgresReadEventMetadata>) => Promise<AggregateStreamResult<State>>;
+export declare function createAggregateStream({ readStream }: {
+    readStream: ReadStream;
+}, { logger }: Dependencies): AggregateStream;
+export {};
+//# sourceMappingURL=aggregate-stream.d.ts.map

package/dist/event-store/aggregate-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-stream.d.ts","sourceRoot":"","sources":["../../src/event-store/aggregate-stream.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,KAAK,EACV,KAAK,mCAAmC,EACzC,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAEL,KAAK,YAAY,EAClB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,KAAK,yBAAyB,GAAG,mCAAmC,CAAC;AAErE,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,SAAS,SAAS,KAAK,EAC3D,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,sBAAsB,CAAC,KAAK,EAAE,SAAS,EAAE,yBAAyB,CAAC,KACzE,OAAO,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC;AAE3C,wBAAgB,qBAAqB,CACnC,EAAE,UAAU,EAAE,EAAE;IAAE,UAAU,EAAE,UAAU,CAAA;CAAE,EAC1C,EAAE,MAAM,EAAE,EAAE,YAAY,GACvB,eAAe,CAgCjB"}

package/dist/event-store/aggregate-stream.js

@@ -0,0 +1,18 @@
+// biome-ignore assist/source/organizeImports: retain import order similar to app code
+import { assertExpectedVersionMatchesCurrent, } from "@event-driven-io/emmett";
+import { PostgreSQLEventStoreDefaultStreamVersion, } from "../types.js";
+export function createAggregateStream({ readStream }, { logger }) {
+    return async function aggregateStream(streamId, options) {
+        const { evolve, initialState, read } = options;
+        logger.info({ streamId, options }, "aggregateStream");
+        const expectedStreamVersion = read?.expectedStreamVersion;
+        const result = await readStream(streamId, options.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,
+        };
+    };
+}

package/dist/event-store/append-to-stream.d.ts

@@ -0,0 +1,7 @@
+import { type AppendToStreamOptions, type AppendToStreamResultWithGlobalPosition, type Event } from "@event-driven-io/emmett";
+import { type Dependencies, type ExtendedOptions } from "../types.js";
+type ExtendedAppendToStreamOptions = AppendToStreamOptions & ExtendedOptions;
+export type AppendToStream = <EventType extends Event>(streamId: string, events: EventType[], options?: ExtendedAppendToStreamOptions) => Promise<AppendToStreamResultWithGlobalPosition>;
+export declare function createAppendToStream({ db, logger, }: Dependencies): AppendToStream;
+export {};
+//# sourceMappingURL=append-to-stream.d.ts.map

package/dist/event-store/append-to-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"append-to-stream.d.ts","sourceRoot":"","sources":["../../src/event-store/append-to-stream.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,qBAAqB,EAC1B,KAAK,sCAAsC,EAC3C,KAAK,KAAK,EACX,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,eAAe,EACrB,MAAM,aAAa,CAAC;AAIrB,KAAK,6BAA6B,GAAG,qBAAqB,GAAG,eAAe,CAAC;AAC7E,MAAM,MAAM,cAAc,GAAG,CAAC,SAAS,SAAS,KAAK,EACnD,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,SAAS,EAAE,EACnB,OAAO,CAAC,EAAE,6BAA6B,KACpC,OAAO,CAAC,sCAAsC,CAAC,CAAC;AAErD,wBAAgB,oBAAoB,CAAC,EACnC,EAAE,EACF,MAAM,GACP,EAAE,YAAY,GAAG,cAAc,CA6D/B"}

package/dist/event-store/append-to-stream.js

@@ -0,0 +1,143 @@
+// biome-ignore assist/source/organizeImports: retain import order similar to app code
+import { ExpectedVersionConflictError, NO_CONCURRENCY_CHECK, STREAM_DOES_NOT_EXIST, STREAM_EXISTS, } from "@event-driven-io/emmett";
+import { DEFAULT_PARTITION, PostgreSQLEventStoreDefaultStreamVersion, } from "../types.js";
+const PostgreSQLEventStoreDefaultGlobalPosition = 0n;
+export function createAppendToStream({ db, logger, }) {
+    return async function appendToStream(streamId, events, options) {
+        const streamType = getStreamType(options);
+        const partition = getPartition(options);
+        const expected = options?.expectedStreamVersion;
+        logger.info({ streamId, events, options, partition }, "appendToStream");
+        ensureEventsNotEmpty(events, expected);
+        const result = await db
+            .transaction()
+            .execute(async (trx) => {
+            const { currentStreamVersion, streamExists } = await fetchStreamInfo(trx, streamId, partition);
+            assertExpectedVersion(expected, currentStreamVersion, streamExists);
+            const basePos = currentStreamVersion;
+            const nextStreamPosition = computeNextStreamPosition(basePos, events.length);
+            await upsertStreamRow(trx, streamId, partition, streamType, basePos, nextStreamPosition, expected, streamExists);
+            const messagesToInsert = buildMessagesToInsert(events, basePos, streamId, partition);
+            const lastEventGlobalPosition = await insertMessagesAndGetLastGlobalPosition(trx, messagesToInsert);
+            return {
+                nextExpectedStreamVersion: nextStreamPosition,
+                lastEventGlobalPosition,
+                createdNewStream: !streamExists,
+            };
+        });
+        return result;
+    };
+}
+function getStreamType(options) {
+    return options?.streamType ?? "unknown";
+}
+function ensureEventsNotEmpty(events, expected) {
+    if (events.length === 0) {
+        throw new ExpectedVersionConflictError(-1n, expected ?? NO_CONCURRENCY_CHECK);
+    }
+}
+function assertExpectedVersion(expected, currentPos, streamExistsNow) {
+    if (expected === STREAM_EXISTS && !streamExistsNow) {
+        throw new ExpectedVersionConflictError(-1n, STREAM_EXISTS);
+    }
+    if (expected === STREAM_DOES_NOT_EXIST && streamExistsNow) {
+        throw new ExpectedVersionConflictError(-1n, STREAM_DOES_NOT_EXIST);
+    }
+    if (typeof expected === "bigint" && expected !== currentPos) {
+        throw new ExpectedVersionConflictError(currentPos, expected);
+    }
+}
+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 ExpectedVersionConflictError(basePos, expected);
+        }
+        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 PostgreSQLEventStoreDefaultGlobalPosition;
+    }
+    const globalPositions = inserted.map((r) => BigInt(String(r.global_position)));
+    return globalPositions[globalPositions.length - 1];
+}
+function getPartition(options) {
+    return options?.partition ?? DEFAULT_PARTITION;
+}
+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 };
+}

package/dist/event-store/index.cjs

@@ -0,0 +1,291 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/event-store/index.ts
+var event_store_exports = {};
+__export(event_store_exports, {
+  createEventStore: () => createEventStore,
+  createReadStream: () => createReadStream
+});
+module.exports = __toCommonJS(event_store_exports);
+
+// src/event-store/aggregate-stream.ts
+var import_emmett = require("@event-driven-io/emmett");
+
+// src/types.ts
+var PostgreSQLEventStoreDefaultStreamVersion = 0n;
+var DEFAULT_PARTITION = "default_partition";
+
+// src/event-store/aggregate-stream.ts
+function createAggregateStream({ readStream }, { logger }) {
+  return async function aggregateStream(streamId, options) {
+    const { evolve, initialState, read } = options;
+    logger.info({ streamId, options }, "aggregateStream");
+    const expectedStreamVersion = read?.expectedStreamVersion;
+    const result = await readStream(streamId, options.read);
+    (0, import_emmett.assertExpectedVersionMatchesCurrent)(
+      result.currentStreamVersion,
+      expectedStreamVersion,
+      PostgreSQLEventStoreDefaultStreamVersion
+    );
+    const state = result.events.reduce(
+      (state2, event) => event ? evolve(state2, event) : state2,
+      initialState()
+    );
+    return {
+      state,
+      currentStreamVersion: result.currentStreamVersion,
+      streamExists: result.streamExists
+    };
+  };
+}
+
+// src/event-store/append-to-stream.ts
+var import_emmett2 = require("@event-driven-io/emmett");
+var PostgreSQLEventStoreDefaultGlobalPosition = 0n;
+function createAppendToStream({
+  db,
+  logger
+}) {
+  return async function appendToStream(streamId, events, options) {
+    const streamType = getStreamType(options);
+    const partition = getPartition(options);
+    const expected = options?.expectedStreamVersion;
+    logger.info({ streamId, events, options, partition }, "appendToStream");
+    ensureEventsNotEmpty(events, expected);
+    const result = await db.transaction().execute(async (trx) => {
+      const { currentStreamVersion, streamExists } = await fetchStreamInfo(
+        trx,
+        streamId,
+        partition
+      );
+      assertExpectedVersion(expected, currentStreamVersion, streamExists);
+      const basePos = currentStreamVersion;
+      const nextStreamPosition = computeNextStreamPosition(
+        basePos,
+        events.length
+      );
+      await upsertStreamRow(
+        trx,
+        streamId,
+        partition,
+        streamType,
+        basePos,
+        nextStreamPosition,
+        expected,
+        streamExists
+      );
+      const messagesToInsert = buildMessagesToInsert(
+        events,
+        basePos,
+        streamId,
+        partition
+      );
+      const lastEventGlobalPosition = await insertMessagesAndGetLastGlobalPosition(trx, messagesToInsert);
+      return {
+        nextExpectedStreamVersion: nextStreamPosition,
+        lastEventGlobalPosition,
+        createdNewStream: !streamExists
+      };
+    });
+    return result;
+  };
+}
+function getStreamType(options) {
+  return options?.streamType ?? "unknown";
+}
+function ensureEventsNotEmpty(events, expected) {
+  if (events.length === 0) {
+    throw new import_emmett2.ExpectedVersionConflictError(
+      -1n,
+      expected ?? import_emmett2.NO_CONCURRENCY_CHECK
+    );
+  }
+}
+function assertExpectedVersion(expected, currentPos, streamExistsNow) {
+  if (expected === import_emmett2.STREAM_EXISTS && !streamExistsNow) {
+    throw new import_emmett2.ExpectedVersionConflictError(-1n, import_emmett2.STREAM_EXISTS);
+  }
+  if (expected === import_emmett2.STREAM_DOES_NOT_EXIST && streamExistsNow) {
+    throw new import_emmett2.ExpectedVersionConflictError(-1n, import_emmett2.STREAM_DOES_NOT_EXIST);
+  }
+  if (typeof expected === "bigint" && expected !== currentPos) {
+    throw new import_emmett2.ExpectedVersionConflictError(currentPos, expected);
+  }
+}
+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 import_emmett2.ExpectedVersionConflictError(basePos, expected);
+    }
+    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 : void 0;
+    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: /* @__PURE__ */ 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 PostgreSQLEventStoreDefaultGlobalPosition;
+  }
+  const globalPositions = inserted.map(
+    (r) => BigInt(String(r.global_position))
+  );
+  return globalPositions[globalPositions.length - 1];
+}
+function getPartition(options) {
+  return options?.partition ?? DEFAULT_PARTITION;
+}
+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 };
+}
+
+// src/event-store/read-stream.ts
+function createReadStream({ db, logger }) {
+  return async function readStream(streamId, options) {
+    const partition = getPartition2(options);
+    logger.info({ streamId, options, partition }, "readStream");
+    const { currentStreamVersion, streamExists } = await fetchStreamInfo2(
+      db,
+      streamId,
+      partition
+    );
+    const range = parseRangeOptions(options);
+    const rows = await buildEventsQuery(
+      { db, logger },
+      streamId,
+      partition,
+      range
+    ).execute();
+    const events = rows.map((row) => mapRowToEvent(row, streamId));
+    return {
+      events,
+      currentStreamVersion,
+      streamExists
+    };
+  };
+}
+function parseRangeOptions(options) {
+  const from = options && typeof options === "object" && "from" in options ? options.from : void 0;
+  const to = options && typeof options === "object" && "to" in options ? options.to : void 0;
+  const maxCount = options && typeof options === "object" && "maxCount" in options ? options.maxCount : void 0;
+  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 !== void 0) {
+    q = q.where("stream_position", ">=", BigInt(range.from));
+  }
+  if (range.to !== void 0) {
+    q = q.where("stream_position", "<=", BigInt(range.to));
+  }
+  if (range.maxCount !== void 0) {
+    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,
+      streamPosition,
+      globalPosition
+    }
+  };
+}
+function getPartition2(options) {
+  return options?.partition ?? DEFAULT_PARTITION;
+}
+async function fetchStreamInfo2(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 ? streamRow.stream_position : PostgreSQLEventStoreDefaultStreamVersion;
+  return { currentStreamVersion, streamExists: !!streamRow };
+}
+
+// src/event-store/index.ts
+function createEventStore(deps) {
+  const readStream = createReadStream(deps);
+  const appendToStream = createAppendToStream(deps);
+  const aggregateStream = createAggregateStream({ readStream }, deps);
+  return { readStream, appendToStream, aggregateStream };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEventStore,
+  createReadStream
+});

package/dist/event-store/index.d.ts

@@ -0,0 +1,13 @@
+import type { Dependencies } from "../types.js";
+export type { DatabaseExecutor, Dependencies, ExtendedOptions, } from "../types.js";
+export type { AggregateStream } from "./aggregate-stream.js";
+export type { AppendToStream } from "./append-to-stream.js";
+export type { ReadStream } from "./read-stream.js";
+export type EventStore = ReturnType<typeof createEventStore>;
+export { createReadStream } from "./read-stream.js";
+export declare function createEventStore(deps: Dependencies): {
+    readStream: import("./read-stream.js").ReadStream;
+    appendToStream: import("./append-to-stream.js").AppendToStream;
+    aggregateStream: import("./aggregate-stream.js").AggregateStream;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/event-store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/event-store/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAKhD,YAAY,EACV,gBAAgB,EAChB,YAAY,EACZ,eAAe,GAChB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,YAAY,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY;;;;EAKlD"}

package/dist/event-store/index.js

@@ -0,0 +1,10 @@
+import { createAggregateStream } from "./aggregate-stream.js";
+import { createAppendToStream } from "./append-to-stream.js";
+import { createReadStream } from "./read-stream.js";
+export { createReadStream } from "./read-stream.js";
+export function createEventStore(deps) {
+    const readStream = createReadStream(deps);
+    const appendToStream = createAppendToStream(deps);
+    const aggregateStream = createAggregateStream({ readStream }, deps);
+    return { readStream, appendToStream, aggregateStream };
+}

package/dist/event-store/read-stream.d.ts

@@ -0,0 +1,14 @@
+import type { Event, ReadEventMetadataWithGlobalPosition, ReadStreamOptions, ReadStreamResult } from "@event-driven-io/emmett";
+import { type Dependencies, type ExtendedOptions } from "../types.js";
+type PostgresReadEventMetadata = ReadEventMetadataWithGlobalPosition;
+type ExtendedReadStreamOptions = ReadStreamOptions & ExtendedOptions;
+type ProjectionReadStreamOptions = {
+    from?: bigint;
+    to?: bigint;
+    partition?: string;
+    maxCount?: bigint;
+};
+export type ReadStream = <EventType extends Event>(stream: string, options?: ExtendedReadStreamOptions | ProjectionReadStreamOptions) => Promise<ReadStreamResult<EventType, PostgresReadEventMetadata>>;
+export declare function createReadStream({ db, logger }: Dependencies): ReadStream;
+export {};
+//# sourceMappingURL=read-stream.d.ts.map

package/dist/event-store/read-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-stream.d.ts","sourceRoot":"","sources":["../../src/event-store/read-stream.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,KAAK,EAEL,mCAAmC,EACnC,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,eAAe,EACrB,MAAM,aAAa,CAAC;AAErB,KAAK,yBAAyB,GAAG,mCAAmC,CAAC;AACrE,KAAK,yBAAyB,GAAG,iBAAiB,GAAG,eAAe,CAAC;AAGrE,KAAK,2BAA2B,GAAG;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,SAAS,SAAS,KAAK,EAC/C,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,yBAAyB,GAAG,2BAA2B,KAC9D,OAAO,CAAC,gBAAgB,CAAC,SAAS,EAAE,yBAAyB,CAAC,CAAC,CAAC;AAErE,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,GAAG,UAAU,CAiCzE"}

package/dist/event-store/read-stream.js

@@ -0,0 +1,88 @@
+import { DEFAULT_PARTITION, PostgreSQLEventStoreDefaultStreamVersion, } from "../types.js";
+export function createReadStream({ db, logger }) {
+    return async function readStream(streamId, options) {
+        const partition = getPartition(options);
+        logger.info({ streamId, options, partition }, "readStream");
+        const { currentStreamVersion, streamExists } = await fetchStreamInfo(db, streamId, partition);
+        const range = parseRangeOptions(options);
+        const rows = await buildEventsQuery({ db, logger }, streamId, partition, range).execute();
+        const events = rows.map((row) => mapRowToEvent(row, streamId));
+        return {
+            events,
+            currentStreamVersion,
+            streamExists,
+        };
+    };
+}
+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", ">=", BigInt(range.from));
+    }
+    if (range.to !== undefined) {
+        q = q.where("stream_position", "<=", BigInt(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,
+        },
+    };
+}
+function getPartition(options) {
+    return options?.partition ?? DEFAULT_PARTITION;
+}
+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
+        ? streamRow.stream_position
+        : PostgreSQLEventStoreDefaultStreamVersion;
+    return { currentStreamVersion, streamExists: !!streamRow };
+}

package/dist/projections/index.cjs

@@ -0,0 +1,124 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/projections/index.ts
+var projections_exports = {};
+__export(projections_exports, {
+  createProjectionRegistry: () => createProjectionRegistry,
+  createProjectionRunner: () => createProjectionRunner
+});
+module.exports = __toCommonJS(projections_exports);
+
+// src/types.ts
+function createProjectionRegistry(...registries) {
+  const combined = {};
+  for (const reg of registries) {
+    for (const [eventType, handlers] of Object.entries(reg)) {
+      combined[eventType] = [...combined[eventType] ?? [], ...handlers];
+    }
+  }
+  return combined;
+}
+
+// src/projections/runner.ts
+function createProjectionRunner({ db, readStream, registry }) {
+  async function getOrCreateCheckpoint(subscriptionId, partition) {
+    const existing = await db.selectFrom("subscriptions").select([
+      "subscription_id as subscriptionId",
+      "partition",
+      "last_processed_position as lastProcessedPosition"
+    ]).where("subscription_id", "=", subscriptionId).where("partition", "=", partition).executeTakeFirst();
+    if (existing) {
+      const last = BigInt(
+        String(
+          existing.lastProcessedPosition
+        )
+      );
+      return {
+        subscriptionId,
+        partition,
+        lastProcessedPosition: last
+      };
+    }
+    await db.insertInto("subscriptions").values({
+      subscription_id: subscriptionId,
+      partition,
+      version: 1,
+      last_processed_position: 0n
+    }).onConflict(
+      (oc) => oc.columns(["subscription_id", "partition", "version"]).doUpdateSet({
+        last_processed_position: (eb) => eb.ref("excluded.last_processed_position")
+      })
+    ).execute();
+    return {
+      subscriptionId,
+      partition,
+      lastProcessedPosition: 0n
+    };
+  }
+  async function updateCheckpoint(subscriptionId, partition, lastProcessedPosition) {
+    await db.updateTable("subscriptions").set({ last_processed_position: lastProcessedPosition }).where("subscription_id", "=", subscriptionId).where("partition", "=", partition).execute();
+  }
+  async function projectEvents(subscriptionId, streamId, opts) {
+    const partition = opts?.partition ?? "default_partition";
+    const batchSize = BigInt(opts?.batchSize ?? 500);
+    const checkpoint = await getOrCreateCheckpoint(subscriptionId, partition);
+    const { events, currentStreamVersion } = await readStream(streamId, {
+      from: checkpoint.lastProcessedPosition + 1n,
+      to: checkpoint.lastProcessedPosition + batchSize,
+      partition
+    });
+    for (const ev of events) {
+      if (!ev) continue;
+      const handlers = registry[ev.type] ?? [];
+      if (handlers.length === 0) {
+        await updateCheckpoint(
+          subscriptionId,
+          partition,
+          ev.metadata.streamPosition
+        );
+        continue;
+      }
+      const projectionEvent = {
+        type: ev.type,
+        data: ev.data,
+        metadata: {
+          streamId: ev.metadata.streamId,
+          streamPosition: ev.metadata.streamPosition,
+          globalPosition: ev.metadata.globalPosition
+        }
+      };
+      for (const handler of handlers) {
+        await handler({ db, partition }, projectionEvent);
+      }
+      await updateCheckpoint(
+        subscriptionId,
+        partition,
+        projectionEvent.metadata.streamPosition
+      );
+    }
+    return { processed: events.length, currentStreamVersion };
+  }
+  return { projectEvents };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createProjectionRegistry,
+  createProjectionRunner
+});

package/dist/projections/index.d.ts

@@ -0,0 +1,4 @@
+export { createProjectionRegistry } from "../types.js";
+export type { ProjectionContext, ProjectionEvent, ProjectionEventMetadata, ProjectionHandler, ProjectionRegistry, } from "../types.js";
+export { createProjectionRunner } from "./runner.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/projections/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/projections/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AACvD,YAAY,EACV,iBAAiB,EACjB,eAAe,EACf,uBAAuB,EACvB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC"}

package/dist/projections/index.js

@@ -0,0 +1,2 @@
+export { createProjectionRegistry } from "../types.js";
+export { createProjectionRunner } from "./runner.js";

package/dist/projections/runner.d.ts

@@ -0,0 +1,21 @@
+import type { DatabaseExecutor, ProjectionRegistry, ReadStream } from "../types.js";
+export type SubscriptionCheckpoint = {
+    subscriptionId: string;
+    partition: string;
+    lastProcessedPosition: bigint;
+};
+export type ProjectionRunnerDeps<T extends DatabaseExecutor = DatabaseExecutor> = {
+    db: T;
+    readStream: ReadStream;
+    registry: ProjectionRegistry<T>;
+};
+export declare function createProjectionRunner<T extends DatabaseExecutor = DatabaseExecutor>({ db, readStream, registry }: ProjectionRunnerDeps<T>): {
+    projectEvents: (subscriptionId: string, streamId: string, opts?: {
+        partition?: string;
+        batchSize?: number;
+    }) => Promise<{
+        processed: number;
+        currentStreamVersion: bigint;
+    }>;
+};
+//# sourceMappingURL=runner.d.ts.map

package/dist/projections/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/projections/runner.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,gBAAgB,EAEhB,kBAAkB,EAClB,UAAU,EACX,MAAM,aAAa,CAAC;AAErB,MAAM,MAAM,sBAAsB,GAAG;IACnC,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,qBAAqB,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,oBAAoB,CAC9B,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,IAC3C;IACF,EAAE,EAAE,CAAC,CAAC;IACN,UAAU,EAAE,UAAU,CAAC;IACvB,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC;CACjC,CAAC;AAEF,wBAAgB,sBAAsB,CACpC,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,EAC7C,EAAE,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,oBAAoB,CAAC,CAAC,CAAC;oCA4EnC,MAAM,YACZ,MAAM,SACT;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE;;;;EAgDpD"}

package/dist/projections/runner.js

@@ -0,0 +1,82 @@
+export function createProjectionRunner({ db, readStream, registry }) {
+    async function getOrCreateCheckpoint(subscriptionId, partition) {
+        const existing = await db
+            .selectFrom("subscriptions")
+            .select([
+            "subscription_id as subscriptionId",
+            "partition",
+            "last_processed_position as lastProcessedPosition",
+        ])
+            .where("subscription_id", "=", subscriptionId)
+            .where("partition", "=", partition)
+            .executeTakeFirst();
+        if (existing) {
+            const last = BigInt(String(existing
+                .lastProcessedPosition));
+            return {
+                subscriptionId,
+                partition,
+                lastProcessedPosition: last,
+            };
+        }
+        await db
+            .insertInto("subscriptions")
+            .values({
+            subscription_id: subscriptionId,
+            partition,
+            version: 1,
+            last_processed_position: 0n,
+        })
+            .onConflict((oc) => oc.columns(["subscription_id", "partition", "version"]).doUpdateSet({
+            last_processed_position: (eb) => eb.ref("excluded.last_processed_position"),
+        }))
+            .execute();
+        return {
+            subscriptionId,
+            partition,
+            lastProcessedPosition: 0n,
+        };
+    }
+    async function updateCheckpoint(subscriptionId, partition, lastProcessedPosition) {
+        await db
+            .updateTable("subscriptions")
+            .set({ last_processed_position: lastProcessedPosition })
+            .where("subscription_id", "=", subscriptionId)
+            .where("partition", "=", partition)
+            .execute();
+    }
+    async function projectEvents(subscriptionId, streamId, opts) {
+        const partition = opts?.partition ?? "default_partition";
+        const batchSize = BigInt(opts?.batchSize ?? 500);
+        const checkpoint = await getOrCreateCheckpoint(subscriptionId, partition);
+        const { events, currentStreamVersion } = await readStream(streamId, {
+            from: checkpoint.lastProcessedPosition + 1n,
+            to: checkpoint.lastProcessedPosition + batchSize,
+            partition,
+        });
+        for (const ev of events) {
+            if (!ev)
+                continue;
+            const handlers = registry[ev.type] ?? [];
+            if (handlers.length === 0) {
+                await updateCheckpoint(subscriptionId, partition, ev.metadata.streamPosition);
+                continue;
+            }
+            const projectionEvent = {
+                type: ev.type,
+                data: ev.data,
+                metadata: {
+                    streamId: ev.metadata.streamId,
+                    streamPosition: ev.metadata.streamPosition,
+                    globalPosition: ev.metadata.globalPosition,
+                },
+            };
+            for (const handler of handlers) {
+                await handler({ db, partition }, projectionEvent);
+            }
+            await updateCheckpoint(subscriptionId, partition, projectionEvent.metadata.streamPosition);
+        }
+        return { processed: events.length, currentStreamVersion };
+    }
+    return { projectEvents };
+}

package/dist/types.d.ts

@@ -0,0 +1,38 @@
+import type { Kysely, Transaction } from "kysely";
+import type { EventStoreDBSchema } from "./db-schema.js";
+export type DatabaseExecutor = Kysely<EventStoreDBSchema> | Transaction<EventStoreDBSchema>;
+export type Logger = {
+    info: (obj: unknown, msg?: string) => void;
+    error: (obj: unknown, msg?: string) => void;
+    warn?: (obj: unknown, msg?: string) => void;
+    debug?: (obj: unknown, msg?: string) => void;
+};
+export type Dependencies = {
+    db: DatabaseExecutor;
+    logger: Logger;
+};
+export type ExtendedOptions = {
+    partition?: string;
+    streamType?: string;
+};
+export declare const PostgreSQLEventStoreDefaultStreamVersion = 0n;
+export declare const DEFAULT_PARTITION: "default_partition";
+export type ProjectionEventMetadata = {
+    streamId: string;
+    streamPosition: bigint;
+    globalPosition: bigint;
+};
+export type ProjectionEvent = {
+    type: string;
+    data: unknown;
+    metadata: ProjectionEventMetadata;
+};
+export type ProjectionContext<T = DatabaseExecutor> = {
+    db: T;
+    partition: string;
+};
+export type ProjectionHandler<T = DatabaseExecutor> = (ctx: ProjectionContext<T>, event: ProjectionEvent) => void | Promise<void>;
+export type ProjectionRegistry<T = DatabaseExecutor> = Record<string, ProjectionHandler<T>[]>;
+export declare function createProjectionRegistry<T = DatabaseExecutor>(...registries: ProjectionRegistry<T>[]): ProjectionRegistry<T>;
+export type { ReadStream } from "./event-store/read-stream.js";
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAClD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAGzD,MAAM,MAAM,gBAAgB,GACxB,MAAM,CAAC,kBAAkB,CAAC,GAC1B,WAAW,CAAC,kBAAkB,CAAC,CAAC;AAEpC,MAAM,MAAM,MAAM,GAAG;IACnB,IAAI,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,KAAK,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5C,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5C,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9C,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,gBAAgB,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,wCAAwC,KAAK,CAAC;AAC3D,eAAO,MAAM,iBAAiB,EAAG,mBAA4B,CAAC;AAG9D,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,uBAAuB,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,iBAAiB,CAAC,CAAC,GAAG,gBAAgB,IAAI;IACpD,EAAE,EAAE,CAAC,CAAC;IACN,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,iBAAiB,CAAC,CAAC,GAAG,gBAAgB,IAAI,CACpD,GAAG,EAAE,iBAAiB,CAAC,CAAC,CAAC,EACzB,KAAK,EAAE,eAAe,KACnB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B,MAAM,MAAM,kBAAkB,CAAC,CAAC,GAAG,gBAAgB,IAAI,MAAM,CAC3D,MAAM,EACN,iBAAiB,CAAC,CAAC,CAAC,EAAE,CACvB,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,CAAC,GAAG,gBAAgB,EAC3D,GAAG,UAAU,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAAE,GACrC,kBAAkB,CAAC,CAAC,CAAC,CAYvB;AAGD,YAAY,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/types.js

@@ -0,0 +1,15 @@
+export const PostgreSQLEventStoreDefaultStreamVersion = 0n;
+export const DEFAULT_PARTITION = "default_partition";
+export function createProjectionRegistry(...registries) {
+    const combined = {};
+    /**
+     * This is necessary because the projection runner can be used to project events from multiple partitions.
+     * e.g., the generators-read-model projection runner can be used to project events for partition A, partition B, and partition C.
+     */
+    for (const reg of registries) {
+        for (const [eventType, handlers] of Object.entries(reg)) {
+            combined[eventType] = [...(combined[eventType] ?? []), ...handlers];
+        }
+    }
+    return combined;
+}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@wataruoguchi/emmett-event-store-kysely",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.1.1",
+  "description": "Emmett Event Store with Kysely",
+  "author": "Wataru Oguchi",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wataruoguchi/poc-emmett.git"
+  },
+  "homepage": "https://github.com/wataruoguchi/poc-emmett",
+  "bugs": "https://github.com/wataruoguchi/poc-emmett/issues",
+  "type": "module",
+  "main": "dist/event-store/index.js",
+  "module": "dist/event-store/index.js",
+  "types": "dist/types.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/event-store/index.d.ts",
+      "import": "./dist/event-store/index.js",
+      "require": "./dist/event-store/index.cjs"
+    },
+    "./event-store": {
+      "types": "./dist/event-store/index.d.ts",
+      "import": "./dist/event-store/index.js",
+      "require": "./dist/event-store/index.cjs"
+    },
+    "./projections": {
+      "types": "./dist/projections/index.d.ts",
+      "import": "./dist/projections/index.js",
+      "require": "./dist/projections/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && tsup src/event-store/index.ts src/projections/index.ts",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "release": "semantic-release",
+    "release:dry-run": "semantic-release --dry-run"
+  },
+  "devDependencies": {
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/github": "^11.0.6",
+    "@semantic-release/npm": "^12.0.2",
+    "@semantic-release/release-notes-generator": "^14.1.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "semantic-release": "^24.2.9",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "@event-driven-io/emmett": "^0.38.5",
+    "kysely": "^0.28.7"
+  },
+  "optionalDependencies": {
+    "@rollup/rollup-linux-x64-gnu": "4.9.5"
+  },
+  "keywords": [
+    "emmett",
+    "event-store",
+    "kysely",
+    "postgres",
+    "postgresql",
+    "Event Sourcing",
+    "event-sourcing",
+    "read-model",
+    "read-models",
+    "read-models-projection",
+    "read-models-projections"
+  ]
+}