@wataruoguchi/emmett-event-store-kysely 1.0.0

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/projections/snapshot-projection.d.ts

@@ -0,0 +1,120 @@
+import type { DatabaseExecutor, ProjectionEvent, ProjectionHandler, ProjectionRegistry } from "../types.js";
+/**
+ * Configuration for snapshot-based projections.
+ *
+ * @template TState - The aggregate state type that will be stored in the snapshot
+ * @template TTable - The table name as a string literal type
+ * @template E - The event union type (must be a discriminated union with type and data properties)
+ */
+export type SnapshotProjectionConfig<TState, TTable extends string, E extends {
+    type: string;
+    data: unknown;
+} = {
+    type: string;
+    data: unknown;
+}> = {
+    /**
+     * The name of the database table for this projection
+     */
+    tableName: TTable;
+    /**
+     * The primary key columns that uniquely identify a row
+     * e.g., ['tenant_id', 'cart_id', 'partition']
+     */
+    primaryKeys: string[];
+    /**
+     * Extract primary key values from the event data
+     */
+    extractKeys: (event: ProjectionEvent<E>, partition: string) => Record<string, string>;
+    /**
+     * The evolve function that takes current state and event, returns new state.
+     * This is the same evolve function used in the aggregate.
+     */
+    evolve: (state: TState, event: ProjectionEvent<E>) => TState;
+    /**
+     * Initial state for the aggregate when no snapshot exists
+     */
+    initialState: () => TState;
+    /**
+     * Optional: Map the snapshot state to individual columns for easier querying.
+     * This allows you to denormalize specific fields from the snapshot into table columns.
+     *
+     * @example
+     * ```typescript
+     * mapToColumns: (state) => ({
+     *   currency: state.currency,
+     *   items_json: JSON.stringify(state.items),
+     *   is_checked_out: state.status === 'checkedOut'
+     * })
+     * ```
+     */
+    mapToColumns?: (state: TState) => Record<string, unknown>;
+};
+/**
+ * Creates a projection handler that stores the aggregate state as a snapshot.
+ *
+ * This is a generic helper that works with any aggregate that follows the evolve pattern.
+ * Instead of manually mapping event fields to table columns, it:
+ * 1. Loads the current snapshot from the database (or starts with initial state)
+ * 2. Applies the event using the evolve function
+ * 3. Stores the new state back to the snapshot column
+ *
+ * @example
+ * ```typescript
+ * const cartProjection = createSnapshotProjection({
+ *   tableName: 'carts',
+ *   primaryKeys: ['tenant_id', 'cart_id', 'partition'],
+ *   extractKeys: (event, partition) => ({
+ *     tenant_id: event.data.eventMeta.tenantId,
+ *     cart_id: event.data.eventMeta.cartId,
+ *     partition
+ *   }),
+ *   evolve: cartEvolve,
+ *   initialState: () => ({ status: 'init', items: [] })
+ * });
+ *
+ * // Use it in a projection registry
+ * const registry: ProjectionRegistry = {
+ *   CartCreated: [cartProjection],
+ *   ItemAddedToCart: [cartProjection],
+ *   // ... other events
+ * };
+ * ```
+ */
+export declare function createSnapshotProjection<TState, TTable extends string, E extends {
+    type: string;
+    data: unknown;
+} = {
+    type: string;
+    data: unknown;
+}>(config: SnapshotProjectionConfig<TState, TTable, E>): ProjectionHandler<DatabaseExecutor, E>;
+/**
+ * Creates multiple projection handlers that all use the same snapshot projection logic.
+ * This is a convenience function to avoid repeating the same handler for multiple event types.
+ *
+ * @example
+ * ```typescript
+ * const registry = createSnapshotProjectionRegistry(
+ *   ['CartCreated', 'ItemAddedToCart', 'ItemRemovedFromCart'],
+ *   {
+ *     tableName: 'carts',
+ *     primaryKeys: ['tenant_id', 'cart_id', 'partition'],
+ *     extractKeys: (event, partition) => ({
+ *       tenant_id: event.data.eventMeta.tenantId,
+ *       cart_id: event.data.eventMeta.cartId,
+ *       partition
+ *     }),
+ *     evolve: cartEvolve,
+ *     initialState: () => ({ status: 'init', items: [] })
+ *   }
+ * );
+ * ```
+ */
+export declare function createSnapshotProjectionRegistry<TState, TTable extends string, E extends {
+    type: string;
+    data: unknown;
+} = {
+    type: string;
+    data: unknown;
+}>(eventTypes: E["type"][], config: SnapshotProjectionConfig<TState, TTable, E>): ProjectionRegistry<DatabaseExecutor>;
+//# sourceMappingURL=snapshot-projection.d.ts.map

package/dist/projections/snapshot-projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-projection.d.ts","sourceRoot":"","sources":["../../src/projections/snapshot-projection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gBAAgB,EAEhB,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,aAAa,CAAC;AAErB;;;;;;GAMG;AACH,MAAM,MAAM,wBAAwB,CAClC,MAAM,EACN,MAAM,SAAS,MAAM,EACrB,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,IACzE;IACF;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,WAAW,EAAE,MAAM,EAAE,CAAC;IAEtB;;OAEG;IACH,WAAW,EAAE,CACX,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,EACzB,SAAS,EAAE,MAAM,KACd,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE5B;;;OAGG;IACH,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;IAE7D;;OAEG;IACH,YAAY,EAAE,MAAM,MAAM,CAAC;IAE3B;;;;;;;;;;;;OAYG;IACH,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC3D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EACN,MAAM,SAAS,MAAM,EACrB,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,EAE3E,MAAM,EAAE,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,GAClD,iBAAiB,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAkGxC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gCAAgC,CAC9C,MAAM,EACN,MAAM,SAAS,MAAM,EACrB,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,EAE3E,UAAU,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,EACvB,MAAM,EAAE,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,GAClD,kBAAkB,CAAC,gBAAgB,CAAC,CAYtC"}

package/dist/projections/snapshot-projection.js

@@ -0,0 +1,135 @@
+/**
+ * Creates a projection handler that stores the aggregate state as a snapshot.
+ *
+ * This is a generic helper that works with any aggregate that follows the evolve pattern.
+ * Instead of manually mapping event fields to table columns, it:
+ * 1. Loads the current snapshot from the database (or starts with initial state)
+ * 2. Applies the event using the evolve function
+ * 3. Stores the new state back to the snapshot column
+ *
+ * @example
+ * ```typescript
+ * const cartProjection = createSnapshotProjection({
+ *   tableName: 'carts',
+ *   primaryKeys: ['tenant_id', 'cart_id', 'partition'],
+ *   extractKeys: (event, partition) => ({
+ *     tenant_id: event.data.eventMeta.tenantId,
+ *     cart_id: event.data.eventMeta.cartId,
+ *     partition
+ *   }),
+ *   evolve: cartEvolve,
+ *   initialState: () => ({ status: 'init', items: [] })
+ * });
+ *
+ * // Use it in a projection registry
+ * const registry: ProjectionRegistry = {
+ *   CartCreated: [cartProjection],
+ *   ItemAddedToCart: [cartProjection],
+ *   // ... other events
+ * };
+ * ```
+ */
+export function createSnapshotProjection(config) {
+    const { tableName, primaryKeys, extractKeys, evolve, initialState, mapToColumns, } = config;
+    return async ({ db, partition }, event) => {
+        const keys = extractKeys(event, partition);
+        // Check if event is newer than what we've already processed
+        // Note: Casting to `any` is necessary because Kysely cannot infer types for dynamic table names.
+        // The table name is provided at runtime, so TypeScript cannot verify the table structure at compile time.
+        // This is a known limitation when working with dynamic table names in Kysely.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const existing = await db
+            .selectFrom(tableName)
+            .select(["last_stream_position", "snapshot"])
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .where((eb) => {
+            const conditions = Object.entries(keys).map(([key, value]) => eb(key, "=", value));
+            return eb.and(conditions);
+        })
+            .executeTakeFirst();
+        const lastPos = existing?.last_stream_position
+            ? BigInt(String(existing.last_stream_position))
+            : -1n;
+        // Skip if we've already processed a newer event
+        if (event.metadata.streamPosition <= lastPos) {
+            return;
+        }
+        // Load current state from snapshot or use initial state
+        // Note: snapshot is stored as JSONB and Kysely returns it as parsed JSON
+        const currentState = existing?.snapshot
+            ? existing.snapshot
+            : initialState();
+        // Apply the event to get new state
+        const newState = evolve(currentState, event);
+        // Prepare the row data with snapshot
+        const rowData = {
+            ...keys,
+            snapshot: JSON.stringify(newState),
+            stream_id: event.metadata.streamId,
+            last_stream_position: event.metadata.streamPosition.toString(),
+            last_global_position: event.metadata.globalPosition.toString(),
+        };
+        // If mapToColumns is provided, add the denormalized columns
+        if (mapToColumns) {
+            const columns = mapToColumns(newState);
+            Object.assign(rowData, columns);
+        }
+        // Upsert the snapshot
+        const insertQuery = db.insertInto(tableName).values(rowData);
+        const updateSet = {
+            snapshot: (eb) => eb.ref("excluded.snapshot"),
+            stream_id: (eb) => eb.ref("excluded.stream_id"),
+            last_stream_position: (eb) => eb.ref("excluded.last_stream_position"),
+            last_global_position: (eb) => eb.ref("excluded.last_global_position"),
+        };
+        // If mapToColumns is provided, also update the denormalized columns
+        if (mapToColumns) {
+            const columns = mapToColumns(newState);
+            for (const columnName of Object.keys(columns)) {
+                updateSet[columnName] = (eb) => eb.ref(`excluded.${columnName}`);
+            }
+        }
+        await insertQuery
+            // Note: `any` is used here because the conflict builder needs to work with any table schema.
+            // The actual schema is validated at runtime through Kysely's query builder.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .onConflict((oc) => {
+            const conflictBuilder = oc.columns(primaryKeys);
+            return conflictBuilder.doUpdateSet(updateSet);
+        })
+            .execute();
+    };
+}
+/**
+ * Creates multiple projection handlers that all use the same snapshot projection logic.
+ * This is a convenience function to avoid repeating the same handler for multiple event types.
+ *
+ * @example
+ * ```typescript
+ * const registry = createSnapshotProjectionRegistry(
+ *   ['CartCreated', 'ItemAddedToCart', 'ItemRemovedFromCart'],
+ *   {
+ *     tableName: 'carts',
+ *     primaryKeys: ['tenant_id', 'cart_id', 'partition'],
+ *     extractKeys: (event, partition) => ({
+ *       tenant_id: event.data.eventMeta.tenantId,
+ *       cart_id: event.data.eventMeta.cartId,
+ *       partition
+ *     }),
+ *     evolve: cartEvolve,
+ *     initialState: () => ({ status: 'init', items: [] })
+ *   }
+ * );
+ * ```
+ */
+export function createSnapshotProjectionRegistry(eventTypes, config) {
+    const handler = createSnapshotProjection(config);
+    const registry = {};
+    for (const eventType of eventTypes) {
+        // Type cast is safe here because ProjectionHandler is contravariant in its event type parameter.
+        // A handler for a specific event type E can safely handle any event that matches E's structure.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        registry[eventType] = [handler];
+    }
+    return registry;
+}

package/dist/types.d.ts

@@ -0,0 +1,77 @@
+import type { Kysely } from "kysely";
+export type DatabaseExecutor<T = any> = Kysely<T>;
+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<T = any> = {
+    db: DatabaseExecutor<T>;
+    logger: Logger;
+    /** If true, the provided db is already a transaction executor. */
+    inTransaction?: boolean;
+};
+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;
+};
+/**
+ * ProjectionEvent that preserves discriminated union relationships.
+ *
+ * Instead of independent EventType and EventData generics, this accepts a union type
+ * where each variant has a specific type-data pairing. This allows TypeScript to
+ * properly narrow the data type when you narrow the event type.
+ *
+ * @example
+ * ```typescript
+ * type MyEvent =
+ *   | { type: "Created"; data: { id: string } }
+ *   | { type: "Updated"; data: { name: string } };
+ *
+ * type MyProjectionEvent = ProjectionEvent<MyEvent>;
+ *
+ * function handle(event: MyProjectionEvent) {
+ *   if (event.type === "Created") {
+ *     // TypeScript knows event.data is { id: string }
+ *     console.log(event.data.id);
+ *   }
+ * }
+ * ```
+ */
+export type ProjectionEvent<E extends {
+    type: string;
+    data: unknown;
+}> = E & {
+    metadata: ProjectionEventMetadata;
+};
+export type ProjectionContext<T = DatabaseExecutor<any>> = {
+    db: T;
+    partition: string;
+};
+export type ProjectionHandler<T = DatabaseExecutor<any>, E extends {
+    type: string;
+    data: unknown;
+} = {
+    type: string;
+    data: unknown;
+}> = (ctx: ProjectionContext<T>, event: ProjectionEvent<E>) => void | Promise<void>;
+/**
+ * ProjectionRegistry maps event types to their handlers.
+ * The `any` in `ProjectionHandler<T, any>[]` is intentional - it allows handlers
+ * for different event types to be registered together, with type safety enforced
+ * at the handler level through the ProjectionHandler generic parameter.
+ */
+export type ProjectionRegistry<T = DatabaseExecutor<any>> = Record<string, ProjectionHandler<T, {
+    type: string;
+    data: unknown;
+}>[]>;
+export declare function createProjectionRegistry<T = DatabaseExecutor<any>>(...registries: ProjectionRegistry<T>[]): ProjectionRegistry<T>;
+//# 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,MAAM,QAAQ,CAAC;AAGrC,MAAM,MAAM,gBAAgB,CAAC,CAAC,GAAG,GAAG,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC;AAElD,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,CAAC,CAAC,GAAG,GAAG,IAAI;IAClC,EAAE,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,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;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,IAAI,CAAC,GAAG;IAC3E,QAAQ,EAAE,uBAAuB,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,iBAAiB,CAAC,CAAC,GAAG,gBAAgB,CAAC,GAAG,CAAC,IAAI;IACzD,EAAE,EAAE,CAAC,CAAC;IACN,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,iBAAiB,CAC3B,CAAC,GAAG,gBAAgB,CAAC,GAAG,CAAC,EACzB,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,IACzE,CACF,GAAG,EAAE,iBAAiB,CAAC,CAAC,CAAC,EACzB,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,KACtB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,GAAG,gBAAgB,CAAC,GAAG,CAAC,IAAI,MAAM,CAChE,MAAM,EACN,iBAAiB,CAAC,CAAC,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,EAAE,CACxD,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,CAAC,GAAG,gBAAgB,CAAC,GAAG,CAAC,EAChE,GAAG,UAAU,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAAE,GACrC,kBAAkB,CAAC,CAAC,CAAC,CAYvB"}

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,72 @@
+{
+  "name": "@wataruoguchi/emmett-event-store-kysely",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.0.0",
+  "description": "Emmett Event Store with Kysely",
+  "author": "Wataru Oguchi",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wataruoguchi/emmett-libs.git"
+  },
+  "homepage": "https://github.com/wataruoguchi/emmett-libs",
+  "bugs": "https://github.com/wataruoguchi/emmett-libs/issues",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/types.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && tsup src/index.ts src/projections/index.ts",
+    "type-check": "tsc --noEmit",
+    "tc": "npm run type-check",
+    "test": "npm run type-check && 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",
+    "conventional-changelog-conventionalcommits": "^9.0.0",
+    "@types/node": "^24.9.2",
+    "@vitest/coverage-v8": "^3.2.4",
+    "semantic-release": "^24.2.9",
+    "semantic-release-monorepo": "^8.0.2",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "@event-driven-io/emmett": "0",
+    "kysely": "0"
+  },
+  "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"
+  ]
+}