@cosmicdrift/kumiko-framework 0.14.0 → 0.16.0

package/src/event-store/__tests__/{upcaster.integration.ts → upcaster.integration.test.ts}

@@ -8,12 +8,12 @@
 //      with only a 1→2 migration fails immediately, so a missing upcaster
 //      can never silently hand half-migrated data to consumers.
 
-import { sql } from "drizzle-orm";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { z } from "zod";
 import { integer as pgInteger, table as pgTable, text as pgText } from "../../db/dialect";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
-import { buildDrizzleTable } from "../../db/table-builder";
+import { asRawClient, insertOne, selectMany } from "../../db/query";
+import { buildEntityTable } from "../../db/table-builder";
 import { createTenantDb, type TenantDb } from "../../db/tenant-db";
 import { createEntity, createRegistry, createTextField, defineFeature } from "../../engine";
 import type { StoredEvent } from "../../event-store";
@@ -36,7 +36,7 @@ const orderEntity = createEntity({
     customer: createTextField({ required: true }),
   },
 });
-const orderTable = buildDrizzleTable("upcast-order", orderEntity);
+const orderTable = buildEntityTable("upcast-order", orderEntity);
 
 // Projection stores the UPCAST view: the v3 shape expects `totalCents` (int)
 // even though the earliest writes might have stored `totalEuros` (string).
@@ -78,18 +78,10 @@ const orderFeature = defineFeature("upcastshop", (r) => {
     apply: {
       [orderPriced.name]: async (event, tx) => {
         const p = event.payload as { totalCents: number; currency: string };
-        await tx
-          .insert(orderSummaryTable)
-          .values({
-            orderId: event.aggregateId,
-            tenantId: event.tenantId,
-            totalCents: p.totalCents,
-            currency: p.currency,
-          })
-          .onConflictDoUpdate({
-            target: orderSummaryTable.orderId,
-            set: { totalCents: p.totalCents, currency: p.currency },
-          });
+        await asRawClient(tx).unsafe(
+          `INSERT INTO "read_upcast_order_summary" (order_id, tenant_id, total_cents, currency) VALUES ($1, $2, $3, $4) ON CONFLICT (order_id) DO UPDATE SET total_cents = $3, currency = $4`,
+          [event.aggregateId, event.tenantId, p.totalCents, p.currency],
+        );
       },
     },
   });
@@ -121,8 +113,8 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await testDb.db.execute(
-    sql`TRUNCATE kumiko_events, read_upcast_orders, read_upcast_order_summary, kumiko_projections RESTART IDENTITY CASCADE`,
+  await asRawClient(testDb.db).unsafe(
+    `TRUNCATE kumiko_events, read_upcast_orders, read_upcast_order_summary, kumiko_projections RESTART IDENTITY CASCADE`,
   );
 });
 
@@ -280,10 +272,7 @@ describe("upcaster: projection rebuild walks the chain on replay", () => {
     });
     expect(result.eventsProcessed).toBe(3);
 
-    const rows = await testDb.db
-      .select()
-      .from(orderSummaryTable)
-      .orderBy(orderSummaryTable.orderId);
+    const rows = await selectMany(testDb.db, orderSummaryTable);
 
     // Ordered by orderId → ord1 (10€ = 1000¢), ord2 ($25.50 = 2550¢), ord3 (9900¢)
     expect(rows).toHaveLength(3);
@@ -305,9 +294,7 @@ describe("upcaster: async (Marten AsyncOnlyEventUpcaster — DB-Lookups)", () =>
       segment: pgText("segment").notNull(),
     });
     await unsafePushTables(testDb.db, { upcastAsyncCustomerSegments: customerSegments });
-    await testDb.db
-      .insert(customerSegments)
-      .values({ customerId: "c-async-1", segment: "PREMIUM" });
+    await insertOne(testDb.db, customerSegments, { customerId: "c-async-1", segment: "PREMIUM" });
 
     const asyncSummary = pgTable("upcast_async_summary", {
       orderId: pgText("order_id").primaryKey(),
@@ -327,11 +314,11 @@ describe("upcaster: async (Marten AsyncOnlyEventUpcaster — DB-Lookups)", () =>
 
       r.eventMigration("placed", 1, 2, async (payload, ctx) => {
         const p = payload as { customerId: string };
-        const [row] = await ctx.db
-          .select()
-          .from(customerSegments)
-          .where(sql`${customerSegments.customerId} = ${p.customerId}`);
-        return { customerId: p.customerId, segment: row?.segment ?? "UNKNOWN" };
+        const [row] = await selectMany(ctx.db, customerSegments, { customerId: p.customerId });
+        return {
+          customerId: p.customerId,
+          segment: (row as { segment?: string } | undefined)?.segment ?? "UNKNOWN",
+        };
       });
 
       r.projection({
@@ -341,7 +328,7 @@ describe("upcaster: async (Marten AsyncOnlyEventUpcaster — DB-Lookups)", () =>
         apply: {
           [placed.name]: async (event, tx) => {
             const p = event.payload as { customerId: string; segment: string };
-            await tx.insert(asyncSummary).values({
+            await insertOne(tx, asyncSummary, {
               orderId: event.aggregateId,
               customerId: p.customerId,
               segment: p.segment,
@@ -384,7 +371,7 @@ describe("upcaster: async (Marten AsyncOnlyEventUpcaster — DB-Lookups)", () =>
     });
     expect(result.eventsProcessed).toBe(2);
 
-    const rows = await testDb.db.select().from(asyncSummary).orderBy(asyncSummary.orderId);
+    const rows = await selectMany(testDb.db, asyncSummary);
     expect(rows).toHaveLength(2);
     const byId = new Map(rows.map((r) => [r.orderId, r]));
     // v1 → v2 via async DB lookup → segment from customer_segments.

package/src/event-store/admin-api.ts

@@ -7,13 +7,18 @@
 // Allowlist: samples/*/migration/, scripts/migrations/, die Definition
 // selbst, das Guard-Script selbst.
 
-import { sql } from "drizzle-orm";
 import type { DbRunner } from "../db";
 import { isUniqueViolation } from "../db/pg-error";
+import {
+  eventPredecessorExists,
+  findExistingEventVersion,
+  insertRawEventBatch,
+  insertRawFirstEvent,
+  insertRawSubsequentEvent,
+} from "../db/queries/event-store-admin";
 import type { TenantId } from "../engine/types";
 import { VersionConflictError } from "./errors";
 import type { EventMetadata } from "./event-store";
-import { eventsTable } from "./events-schema";
 
 export type RawEventToAppend = {
   readonly aggregateId: string;
@@ -55,30 +60,28 @@ export async function appendRaw(runner: DbRunner, event: RawEventToAppend): Prom
   }
 }
 
+function rawEventParams(event: RawEventToAppend, newVersion: number, eventVersion: number) {
+  return {
+    aggregateId: event.aggregateId,
+    aggregateType: event.aggregateType,
+    tenantId: event.tenantId,
+    newVersion,
+    type: event.type,
+    eventVersion,
+    payloadJson: JSON.stringify(event.payload),
+    metadataJson: JSON.stringify(event.metadata),
+    createdAt: event.createdAt.toString(),
+    createdBy: event.createdBy,
+  };
+}
+
 async function insertRawFirst(
   runner: DbRunner,
   event: RawEventToAppend,
   newVersion: number,
   eventVersion: number,
 ): Promise<void> {
-  await runner.execute(sql`
-    INSERT INTO ${eventsTable} (
-      aggregate_id, aggregate_type, tenant_id, version,
-      type, event_version, payload, metadata, created_at, created_by
-    )
-    VALUES (
-      ${event.aggregateId}::uuid,
-      ${event.aggregateType},
-      ${event.tenantId}::uuid,
-      ${newVersion},
-      ${event.type},
-      ${eventVersion},
-      ${JSON.stringify(event.payload)}::jsonb,
-      ${JSON.stringify(event.metadata)}::jsonb,
-      ${event.createdAt.toString()}::timestamptz,
-      ${event.createdBy}
-    )
-  `);
+  await insertRawFirstEvent(runner, rawEventParams(event, newVersion, eventVersion));
 }
 
 async function insertRawSubsequent(
@@ -87,30 +90,11 @@ async function insertRawSubsequent(
   newVersion: number,
   eventVersion: number,
 ): Promise<void> {
-  const rows = await runner.execute<{ id: string }>(sql`
-    INSERT INTO ${eventsTable} (
-      aggregate_id, aggregate_type, tenant_id, version,
-      type, event_version, payload, metadata, created_at, created_by
-    )
-    SELECT ${event.aggregateId}::uuid,
-           ${event.aggregateType},
-           ${event.tenantId}::uuid,
-           ${newVersion},
-           ${event.type},
-           ${eventVersion},
-           ${JSON.stringify(event.payload)}::jsonb,
-           ${JSON.stringify(event.metadata)}::jsonb,
-           ${event.createdAt.toString()}::timestamptz,
-           ${event.createdBy}
-    WHERE EXISTS (
-      SELECT 1 FROM ${eventsTable}
-      WHERE aggregate_id = ${event.aggregateId}::uuid
-        AND version = ${event.expectedVersion}
-        AND tenant_id = ${event.tenantId}::uuid
-    )
-    RETURNING id
-  `);
-  if (rows.length === 0) {
+  const inserted = await insertRawSubsequentEvent(runner, {
+    ...rawEventParams(event, newVersion, eventVersion),
+    expectedVersion: event.expectedVersion,
+  });
+  if (!inserted) {
     throw new VersionConflictError(event.aggregateId, event.expectedVersion);
   }
 }
@@ -133,31 +117,28 @@ export async function appendRawBatch(
   await verifyPredecessors(runner, events);
   await verifyNoDuplicates(runner, events);
 
-  const rows = events.map((e) => {
+  const params: unknown[] = [];
+  const valuesClauses = events.map((e) => {
     const newVersion = e.expectedVersion + 1;
     const eventVersion = e.eventVersion ?? 1;
-    return sql`(
-      ${e.aggregateId}::uuid,
-      ${e.aggregateType},
-      ${e.tenantId}::uuid,
-      ${newVersion},
-      ${e.type},
-      ${eventVersion},
-      ${JSON.stringify(e.payload)}::jsonb,
-      ${JSON.stringify(e.metadata)}::jsonb,
-      ${e.createdAt.toString()}::timestamptz,
-      ${e.createdBy}
-    )`;
+    const baseIdx = params.length;
+    params.push(
+      e.aggregateId,
+      e.aggregateType,
+      e.tenantId,
+      newVersion,
+      e.type,
+      eventVersion,
+      JSON.stringify(e.payload),
+      JSON.stringify(e.metadata),
+      e.createdAt.toString(),
+      e.createdBy,
+    );
+    return `($${baseIdx + 1}::uuid, $${baseIdx + 2}, $${baseIdx + 3}::uuid, $${baseIdx + 4}, $${baseIdx + 5}, $${baseIdx + 6}, $${baseIdx + 7}::jsonb, $${baseIdx + 8}::jsonb, $${baseIdx + 9}::timestamptz, $${baseIdx + 10})`;
   });
 
   try {
-    await runner.execute(sql`
-      INSERT INTO ${eventsTable} (
-        aggregate_id, aggregate_type, tenant_id, version,
-        type, event_version, payload, metadata, created_at, created_by
-      )
-      VALUES ${sql.join(rows, sql`, `)}
-    `);
+    await insertRawEventBatch(runner, valuesClauses.join(", "), params);
   } catch (e) {
     if (isUniqueViolation(e)) {
       // Pre-flight ran but lost a race against a concurrent writer. Rare for
@@ -221,15 +202,8 @@ async function verifyPredecessors(
 
   for (const g of groups.values()) {
     if (g.minExpected === 0) continue;
-    const rows = await runner.execute<{ present: boolean }>(sql`
-      SELECT EXISTS(
-        SELECT 1 FROM ${eventsTable}
-        WHERE aggregate_id = ${g.aggregateId}::uuid
-          AND tenant_id = ${g.tenantId}::uuid
-          AND version = ${g.minExpected}
-      ) AS present
-    `);
-    if (!rows[0]?.present) {
+    const present = await eventPredecessorExists(runner, g.aggregateId, g.tenantId, g.minExpected);
+    if (!present) {
       throw new VersionConflictError(g.aggregateId, g.minExpected);
     }
   }
@@ -242,16 +216,14 @@ async function verifyNoDuplicates(
   runner: DbRunner,
   events: readonly RawEventToAppend[],
 ): Promise<void> {
-  const triples = events.map(
-    (e) => sql`(${e.tenantId}::uuid, ${e.aggregateId}::uuid, ${e.expectedVersion + 1})`,
-  );
-  const rows = await runner.execute<{ aggregate_id: string; version: number }>(sql`
-    SELECT aggregate_id, version FROM ${eventsTable}
-    WHERE (tenant_id, aggregate_id, version) IN (${sql.join(triples, sql`, `)})
-    LIMIT 1
-  `);
-  const conflict = rows[0];
+  const params: unknown[] = [];
+  const tripleClauses = events.map((e) => {
+    const baseIdx = params.length;
+    params.push(e.tenantId, e.aggregateId, e.expectedVersion + 1);
+    return `($${baseIdx + 1}::uuid, $${baseIdx + 2}::uuid, $${baseIdx + 3})`;
+  });
+  const conflict = await findExistingEventVersion(runner, tripleClauses.join(", "), params);
   if (conflict) {
-    throw new VersionConflictError(conflict.aggregate_id, conflict.version - 1);
+    throw new VersionConflictError(conflict.aggregateId, conflict.version - 1);
   }
 }

package/src/event-store/archive.ts

@@ -1,6 +1,9 @@
-import { and, eq, sql } from "drizzle-orm";
+// sql now comes from native dialect
+
 import type { DbConnection, DbRunner } from "../db/connection";
-import { instant, table as pgTable, text, uniqueIndex, uuid } from "../db/dialect";
+import { instant, table as pgTable, sql, text, uniqueIndex, uuid } from "../db/dialect";
+import { upsertArchivedStream } from "../db/queries/event-store";
+import { deleteMany, fetchOne } from "../db/query";
 import { tableExists } from "../db/schema-inspection";
 import type { TenantId } from "../engine/types";
 import { unsafePushTables } from "../stack";
@@ -46,24 +49,13 @@ export type ArchiveStreamArgs = {
 // aggregate) updates archivedAt/archivedBy to the latest call instead of
 // failing. That matches Marten's "archive is a state, not an event" model.
 export async function archiveStream(db: DbRunner, args: ArchiveStreamArgs): Promise<void> {
-  await db
-    .insert(archivedStreamsTable)
-    .values({
-      tenantId: args.tenantId,
-      aggregateId: args.aggregateId,
-      aggregateType: args.aggregateType,
-      archivedBy: args.archivedBy,
-      reason: args.reason ?? null,
-    })
-    .onConflictDoUpdate({
-      target: [archivedStreamsTable.tenantId, archivedStreamsTable.aggregateId],
-      set: {
-        archivedAt: sql`now()`,
-        archivedBy: args.archivedBy,
-        aggregateType: args.aggregateType,
-        reason: args.reason ?? null,
-      },
-    });
+  await upsertArchivedStream(db, {
+    tenantId: args.tenantId,
+    aggregateId: args.aggregateId,
+    aggregateType: args.aggregateType,
+    archivedBy: args.archivedBy,
+    reason: args.reason ?? null,
+  });
 }
 
 // Cheap existence probe — issued in the hot read path, so keep the query to
@@ -73,17 +65,8 @@ export async function isStreamArchived(
   tenantId: TenantId,
   aggregateId: string,
 ): Promise<boolean> {
-  const rows = await db
-    .select({ one: sql`1` })
-    .from(archivedStreamsTable)
-    .where(
-      and(
-        eq(archivedStreamsTable.tenantId, tenantId),
-        eq(archivedStreamsTable.aggregateId, aggregateId),
-      ),
-    )
-    .limit(1);
-  return rows.length > 0;
+  const row = await fetchOne(db, archivedStreamsTable, { tenantId, aggregateId });
+  return row !== undefined;
 }
 
 // Undo an archive — restores the stream to writable state. Ops tool. The
@@ -95,12 +78,5 @@ export async function restoreStream(
   tenantId: TenantId,
   aggregateId: string,
 ): Promise<void> {
-  await db
-    .delete(archivedStreamsTable)
-    .where(
-      and(
-        eq(archivedStreamsTable.tenantId, tenantId),
-        eq(archivedStreamsTable.aggregateId, aggregateId),
-      ),
-    );
+  await deleteMany(db, archivedStreamsTable, { tenantId, aggregateId });
 }

package/src/event-store/event-store.ts

@@ -1,6 +1,13 @@
-import { and, asc, eq, gt, lte, max, sql } from "drizzle-orm";
 import type { DbRunner } from "../db";
 import { isUniqueViolation } from "../db/pg-error";
+import {
+  insertSubsequentEventRow,
+  notifyPgChannel,
+  selectAggregateMaxVersion,
+  selectEventsHighWaterMark,
+  selectStreamMaxVersion,
+} from "../db/queries/event-store";
+import { insertOne, selectMany } from "../db/query";
 import type { TenantId } from "../engine/types";
 import { isStreamArchived } from "./archive";
 import { VersionConflictError } from "./errors";
@@ -60,7 +67,19 @@ export type StoredEvent<TPayload = Record<string, unknown>> = {
   readonly createdBy: string;
 };
 
-type SelectedEvent = typeof eventsTable.$inferSelect;
+type SelectedEvent = {
+  readonly id: bigint;
+  readonly aggregateId: string;
+  readonly aggregateType: string;
+  readonly tenantId: TenantId;
+  readonly version: number;
+  readonly type: string;
+  readonly eventVersion: number;
+  readonly payload: Record<string, unknown>;
+  readonly metadata: EventMetadata;
+  readonly createdAt: Temporal.Instant;
+  readonly createdBy: string;
+};
 
 // Append one event atomically. Two guarantees combined:
 //
@@ -99,7 +118,7 @@ export async function append(db: DbRunner, event: EventToAppend): Promise<Stored
     // NOTIFY fires on commit (PG buffers NOTIFY per TX), so subscribers never
     // see a wake-up for an event that later rolled back. Harmless no-op when
     // no LISTENer is attached.
-    await db.execute(sql`SELECT pg_notify(${EVENTS_PUBSUB_CHANNEL}, '')`);
+    await notifyPgChannel(db, EVENTS_PUBSUB_CHANNEL);
 
     return buildStoredEvent(event, newVersion, eventVersion, row);
   } catch (e) {
@@ -122,22 +141,19 @@ async function insertFirstEvent(
   newVersion: number,
   eventVersion: number,
 ): Promise<InsertReturn> {
-  const [row] = await db
-    .insert(eventsTable)
-    .values({
-      aggregateId: event.aggregateId,
-      aggregateType: event.aggregateType,
-      tenantId: event.tenantId,
-      version: newVersion,
-      type: event.type,
-      eventVersion,
-      payload: event.payload,
-      metadata: event.metadata,
-      createdBy: event.metadata.userId,
-    })
-    .returning({ id: eventsTable.id, createdAt: eventsTable.createdAt });
+  const row = await insertOne<{ id: bigint; createdAt: Temporal.Instant }>(db, eventsTable, {
+    aggregateId: event.aggregateId,
+    aggregateType: event.aggregateType,
+    tenantId: event.tenantId,
+    version: newVersion,
+    type: event.type,
+    eventVersion,
+    payload: event.payload,
+    metadata: event.metadata,
+    createdBy: event.metadata.userId,
+  });
   if (!row) throw new Error("insertFirstEvent: INSERT RETURNING produced no row");
-  return row;
+  return { id: row.id, createdAt: row.createdAt };
 }
 
 // Subsequent event — predecessor must exist AND belong to the same tenant.
@@ -150,31 +166,21 @@ async function insertSubsequentEvent(
   newVersion: number,
   eventVersion: number,
 ): Promise<InsertReturn> {
-  const payloadJson = JSON.stringify(event.payload);
-  const metadataJson = JSON.stringify(event.metadata);
-  const rows = await db.execute<{ id: string; created_at: Date | string }>(sql`
-    INSERT INTO ${eventsTable} (
-      aggregate_id, aggregate_type, tenant_id, version,
-      type, event_version, payload, metadata, created_by
-    )
-    SELECT ${event.aggregateId}::uuid, ${event.aggregateType}, ${event.tenantId}::uuid, ${newVersion},
-           ${event.type}, ${eventVersion}, ${payloadJson}::jsonb,
-           ${metadataJson}::jsonb, ${event.metadata.userId}
-    WHERE EXISTS (
-      SELECT 1 FROM ${eventsTable}
-      WHERE aggregate_id = ${event.aggregateId}::uuid
-        AND version = ${event.expectedVersion}
-        AND tenant_id = ${event.tenantId}::uuid
-    )
-    RETURNING id, created_at;
-  `);
-  const row = rows[0];
+  const row = await insertSubsequentEventRow(db, {
+    aggregateId: event.aggregateId,
+    aggregateType: event.aggregateType,
+    tenantId: event.tenantId,
+    newVersion,
+    type: event.type,
+    eventVersion,
+    payloadJson: JSON.stringify(event.payload),
+    metadataJson: JSON.stringify(event.metadata),
+    createdBy: event.metadata.userId,
+    expectedVersion: event.expectedVersion,
+  });
   if (!row) throw new VersionConflictError(event.aggregateId, event.expectedVersion);
   return {
-    id: BigInt(row.id),
-    // Raw SQL bypasses Drizzle's customType — postgres-js returns Date or
-    // string depending on driver-config. Normalize through Temporal.Instant
-    // so the InsertReturn shape matches the typed-builder path.
+    id: typeof row.id === "bigint" ? row.id : BigInt(row.id),
     createdAt:
       row.created_at instanceof Date
         ? Temporal.Instant.fromEpochMilliseconds(row.created_at.getTime())
@@ -221,11 +227,12 @@ export async function loadAggregate(
     const archived = await isStreamArchived(db, tenantId, aggregateId);
     if (archived) return [];
   }
-  const rows = await db
-    .select()
-    .from(eventsTable)
-    .where(and(eq(eventsTable.aggregateId, aggregateId), eq(eventsTable.tenantId, tenantId)))
-    .orderBy(asc(eventsTable.version));
+  const rows = await selectMany<SelectedEvent>(
+    db,
+    eventsTable,
+    { aggregateId, tenantId },
+    { orderBy: { col: "version", direction: "asc" } },
+  );
   return rows.map(toStoredEvent);
 }
 
@@ -243,17 +250,12 @@ export async function loadAggregateAsOf(
     const archived = await isStreamArchived(db, tenantId, aggregateId);
     if (archived) return [];
   }
-  const rows = await db
-    .select()
-    .from(eventsTable)
-    .where(
-      and(
-        eq(eventsTable.aggregateId, aggregateId),
-        eq(eventsTable.tenantId, tenantId),
-        lte(eventsTable.createdAt, asOf),
-      ),
-    )
-    .orderBy(asc(eventsTable.version));
+  const rows = await selectMany<SelectedEvent>(
+    db,
+    eventsTable,
+    { aggregateId, tenantId, createdAt: { lte: asOf } },
+    { orderBy: { col: "version", direction: "asc" } },
+  );
   return rows.map(toStoredEvent);
 }
 
@@ -268,11 +270,15 @@ export async function getStreamVersion(
   aggregateId: string,
   tenantId: TenantId,
 ): Promise<number> {
-  const [row] = await db
-    .select({ v: max(eventsTable.version) })
-    .from(eventsTable)
-    .where(and(eq(eventsTable.aggregateId, aggregateId), eq(eventsTable.tenantId, tenantId)));
-  return row?.v ?? 0;
+  return selectStreamMaxVersion(db, aggregateId, tenantId);
+}
+
+/** MAX(version) for one aggregate — no tenant filter. Used by seed idempotency. */
+export async function getAggregateStreamMaxVersion(
+  db: DbRunner,
+  aggregateId: string,
+): Promise<number> {
+  return selectAggregateMaxVersion(db, aggregateId);
 }
 
 // Global high-water-mark = MAX(events.id). Marten/Wolverine standard for
@@ -280,8 +286,7 @@ export async function getStreamVersion(
 // the bigserial PK index — sub-millisecond cost. Returns 0n on an empty log
 // (boot, fresh tenant, post-archive).
 export async function getEventsHighWaterMark(db: DbRunner): Promise<bigint> {
-  const [row] = await db.select({ max: max(eventsTable.id) }).from(eventsTable);
-  return row?.max ?? 0n;
+  return selectEventsHighWaterMark(db);
 }
 
 // Load events strictly newer than a given version. Used by snapshot-aware
@@ -293,17 +298,12 @@ export async function loadEventsAfterVersion(
   tenantId: TenantId,
   afterVersion: number,
 ): Promise<readonly StoredEvent[]> {
-  const rows = await db
-    .select()
-    .from(eventsTable)
-    .where(
-      and(
-        eq(eventsTable.aggregateId, aggregateId),
-        eq(eventsTable.tenantId, tenantId),
-        gt(eventsTable.version, afterVersion),
-      ),
-    )
-    .orderBy(asc(eventsTable.version));
+  const rows = await selectMany<SelectedEvent>(
+    db,
+    eventsTable,
+    { aggregateId, tenantId, version: { gt: afterVersion } },
+    { orderBy: { col: "version", direction: "asc" } },
+  );
   return rows.map(toStoredEvent);
 }
 
@@ -319,11 +319,17 @@ export async function loadAllEventsByType(
   db: DbRunner,
   aggregateType: string,
 ): Promise<readonly StoredEvent[]> {
-  const rows = await db
-    .select()
-    .from(eventsTable)
-    .where(eq(eventsTable.aggregateType, aggregateType))
-    .orderBy(asc(eventsTable.createdAt), asc(eventsTable.id));
+  const rows = await selectMany<SelectedEvent>(
+    db,
+    eventsTable,
+    { aggregateType },
+    {
+      orderBy: [
+        { col: "createdAt", direction: "asc" },
+        { col: "id", direction: "asc" },
+      ],
+    },
+  );
   return rows.map(toStoredEvent);
 }
 
@@ -359,12 +365,12 @@ export async function* streamAllEventsByType(
   let cursorId = 0n;
   while (true) {
     signal?.throwIfAborted();
-    const rows = await db
-      .select()
-      .from(eventsTable)
-      .where(and(eq(eventsTable.aggregateType, aggregateType), gt(eventsTable.id, cursorId)))
-      .orderBy(asc(eventsTable.id))
-      .limit(batchSize);
+    const rows = await selectMany<SelectedEvent>(
+      db,
+      eventsTable,
+      { aggregateType, id: { gt: cursorId } },
+      { orderBy: { col: "id", direction: "asc" }, limit: batchSize },
+    );
 
     if (rows.length === 0) {
       // skip: end of stream — generator exit is the natural termination.

package/src/event-store/events-schema.ts

@@ -1,4 +1,4 @@
-import { sql } from "drizzle-orm";
+// sql now comes from native dialect
 import { type DbConnection, tableExists } from "../db";
 import {
   bigserial,
@@ -7,6 +7,7 @@ import {
   integer,
   jsonb,
   table as pgTable,
+  sql,
   text,
   uniqueIndex,
   uuid,

package/src/event-store/index.ts

@@ -12,6 +12,7 @@ export {
   EVENTS_PUBSUB_CHANNEL,
   type EventMetadata,
   type EventToAppend,
+  getAggregateStreamMaxVersion,
   getEventsHighWaterMark,
   getStreamVersion,
   loadAggregate,