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

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,CA2FxC;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,CAStC"}

package/dist/projections/snapshot-projection.js

@@ -0,0 +1,125 @@
+/**
+ * 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
+        const existing = await db
+            .selectFrom(tableName)
+            .select(["last_stream_position", "snapshot"])
+            .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
+            .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) {
+        registry[eventType] = [handler];
+    }
+    return registry;
+}

package/dist/types.d.ts

@@ -1,14 +1,13 @@
-import type { Kysely, Transaction } from "kysely";
-import type { EventStoreDBSchema } from "./db-schema.js";
-export type DatabaseExecutor = Kysely<EventStoreDBSchema> | Transaction<EventStoreDBSchema>;
+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 = {
-    db: DatabaseExecutor;
+export type Dependencies<T = any> = {
+    db: DatabaseExecutor<T>;
     logger: Logger;
 };
 export type ExtendedOptions = {
@@ -22,17 +21,46 @@ export type ProjectionEventMetadata = {
     streamPosition: bigint;
     globalPosition: bigint;
 };
-export type ProjectionEvent = {
+/**
+ * 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> = {
+export type ProjectionContext<T = DatabaseExecutor<any>> = {
     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";
+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>;
+export type ProjectionRegistry<T = DatabaseExecutor<any>> = Record<string, ProjectionHandler<T, any>[]>;
+export declare function createProjectionRegistry<T = DatabaseExecutor<any>>(...registries: ProjectionRegistry<T>[]): ProjectionRegistry<T>;
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +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"}
+{"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;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;;;;;;;;;;;;;;;;;;;;;;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,MAAM,MAAM,kBAAkB,CAAC,CAAC,GAAG,gBAAgB,CAAC,GAAG,CAAC,IAAI,MAAM,CAChE,MAAM,EACN,iBAAiB,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAC5B,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/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.2",
+  "version": "2.0.0",
   "description": "Emmett Event Store with Kysely",
   "author": "Wataru Oguchi",
   "license": "MIT",
@@ -14,22 +14,17 @@
   "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",
+  "main": "dist/index.js",
+  "module": "dist/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"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     },
     "./projections": {
       "types": "./dist/projections/index.d.ts",
@@ -38,9 +33,9 @@
     }
   },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json && tsup src/event-store/index.ts src/projections/index.ts",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && tsup src/index.ts src/projections/index.ts",
     "type-check": "tsc --noEmit",
-    "test": "vitest run",
+    "test": "npm run type-check && vitest run",
     "release": "semantic-release",
     "release:dry-run": "semantic-release --dry-run"
   },
@@ -56,7 +51,7 @@
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "@event-driven-io/emmett": "^0.38.5",
+    "@event-driven-io/emmett": "^0.38.6",
     "kysely": "^0.28.7"
   },
   "optionalDependencies": {

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

@@ -1,10 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,18 +0,0 @@
-// 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

@@ -1,7 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,143 +0,0 @@
-// 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 };
-}