@cosmicdrift/kumiko-bundled-features 0.14.0 → 0.15.0

package/src/delivery/__tests__/delivery.integration.ts

@@ -1,5 +1,7 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { deleteMany, selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
 import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
-import { buildDrizzleTable, createEventStoreExecutor } from "@cosmicdrift/kumiko-framework/db";
+import { buildEntityTable, createEventStoreExecutor } from "@cosmicdrift/kumiko-framework/db";
 import {
   createEntity,
   createTextField,
@@ -15,8 +17,6 @@ import {
   TestUsers,
   unsafePushTables,
 } from "@cosmicdrift/kumiko-framework/stack";
-import { and, eq } from "drizzle-orm";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
 import { z } from "zod";
 import { createChannelEmailFeature } from "../../channel-email/feature";
 import { createInMemoryTransport, type EmailMessage } from "../../channel-email/types";
@@ -176,7 +176,7 @@ const ticketEntity = createEntity({
     status: createTextField({ required: true }),
   },
 });
-const ticketTable = buildDrizzleTable("ticket", ticketEntity);
+const ticketTable = buildEntityTable("ticket", ticketEntity);
 
 function ticketExecutor() {
   return createEventStoreExecutor(ticketTable, ticketEntity, { entityName: "ticket" });
@@ -346,10 +346,7 @@ describe("flow 1: handler sends notification via ctx.notify()", () => {
     expect(result).toEqual({ assigned: true });
 
     // InApp message in DB
-    const messages = await db
-      .select()
-      .from(inAppMessagesTable)
-      .where(eq(inAppMessagesTable.userId, user1.id));
+    const messages = await selectMany(db, inAppMessagesTable, { userId: user1.id });
     expect(messages).toHaveLength(1);
     expect(messages[0]?.["title"]).toBe("Neuer Auftrag");
     expect(messages[0]?.["body"]).toBe("Auftrag #42 wurde dir zugewiesen");
@@ -361,10 +358,9 @@ describe("flow 1: handler sends notification via ctx.notify()", () => {
     expect(sseEvents[0]?.data["userId"]).toBe(user1.id);
 
     // DeliveryLog entries for all 3 channels
-    const logs = await db
-      .select()
-      .from(deliveryAttemptsTable)
-      .where(eq(deliveryAttemptsTable.notificationType, "app:notify:order-assigned"));
+    const logs = await selectMany(db, deliveryAttemptsTable, {
+      notificationType: "app:notify:order-assigned",
+    });
     expect(logs).toHaveLength(3);
     const channels = logs.map((l) => l["channel"]);
     expect(channels).toContain("inApp");
@@ -452,15 +448,10 @@ describe("flow 3: broadcast to multiple users + markAllRead", () => {
 
     // Both users have messages in DB
     for (const user of [user1, user2]) {
-      const messages = await db
-        .select()
-        .from(inAppMessagesTable)
-        .where(
-          and(
-            eq(inAppMessagesTable.userId, user.id),
-            eq(inAppMessagesTable.notificationType, "app:notify:announcement"),
-          ),
-        );
+      const messages = await selectMany(db, inAppMessagesTable, {
+        userId: user.id,
+        notificationType: "app:notify:announcement",
+      });
       expect(messages).toHaveLength(1);
     }
 
@@ -473,10 +464,9 @@ describe("flow 3: broadcast to multiple users + markAllRead", () => {
   });
 
   test("delivery log has entries for all recipients and channels", async () => {
-    const logs = await db
-      .select()
-      .from(deliveryAttemptsTable)
-      .where(eq(deliveryAttemptsTable.notificationType, "app:notify:announcement"));
+    const logs = await selectMany(db, deliveryAttemptsTable, {
+      notificationType: "app:notify:announcement",
+    });
 
     // 2 users × 3 channels (inApp + email + push) = 6 entries
     expect(logs).toHaveLength(6);
@@ -530,28 +520,18 @@ describe("flow 4: declarative notification via r.notification()", () => {
     );
 
     // user1 gets ticketAssigned, admin gets ticketCreatedAdmin
-    const user1Messages = await db
-      .select()
-      .from(inAppMessagesTable)
-      .where(
-        and(
-          eq(inAppMessagesTable.userId, user1.id),
-          eq(inAppMessagesTable.notificationType, "tickets:notify:ticket-assigned"),
-        ),
-      );
+    const user1Messages = await selectMany(db, inAppMessagesTable, {
+      userId: user1.id,
+      notificationType: "tickets:notify:ticket-assigned",
+    });
     expect(user1Messages).toHaveLength(1);
     expect(user1Messages[0]?.["title"]).toBe("Neues Ticket");
     expect(user1Messages[0]?.["body"]).toContain("Server down");
 
-    const adminMessages = await db
-      .select()
-      .from(inAppMessagesTable)
-      .where(
-        and(
-          eq(inAppMessagesTable.userId, admin.id),
-          eq(inAppMessagesTable.notificationType, "tickets:notify:ticket-created-admin"),
-        ),
-      );
+    const adminMessages = await selectMany(db, inAppMessagesTable, {
+      userId: admin.id,
+      notificationType: "tickets:notify:ticket-created-admin",
+    });
     expect(adminMessages).toHaveLength(1);
     expect(adminMessages[0]?.["title"]).toBe("Ticket erstellt");
 
@@ -564,16 +544,11 @@ describe("flow 4: declarative notification via r.notification()", () => {
   });
 
   test("delivery log entries for both notifications", async () => {
-    const logs = await db
-      .select()
-      .from(deliveryAttemptsTable)
-      .where(
-        and(
-          eq(deliveryAttemptsTable.channel, "inApp"),
-          eq(deliveryAttemptsTable.recipientId, user1.id),
-          eq(deliveryAttemptsTable.notificationType, "tickets:notify:ticket-assigned"),
-        ),
-      );
+    const logs = await selectMany(db, deliveryAttemptsTable, {
+      channel: "inApp",
+      recipientId: user1.id,
+      notificationType: "tickets:notify:ticket-assigned",
+    });
     expect(logs).toHaveLength(1);
     expect(logs[0]?.["status"]).toBe("sent");
   });
@@ -592,18 +567,16 @@ describe("flow 5: notification skipped when recipient is null", () => {
     );
 
     // No ticketAssigned notification (no assignee)
-    const assigneeNotifs = await db
-      .select()
-      .from(inAppMessagesTable)
-      .where(eq(inAppMessagesTable.notificationType, "tickets:notify:ticket-assigned"));
+    const assigneeNotifs = await selectMany(db, inAppMessagesTable, {
+      notificationType: "tickets:notify:ticket-assigned",
+    });
     // Only the one from flow 4 should exist
     expect(assigneeNotifs).toHaveLength(1);
 
     // But admin still gets ticketCreatedAdmin
-    const adminMessages = await db
-      .select()
-      .from(inAppMessagesTable)
-      .where(eq(inAppMessagesTable.notificationType, "tickets:notify:ticket-created-admin"));
+    const adminMessages = await selectMany(db, inAppMessagesTable, {
+      notificationType: "tickets:notify:ticket-created-admin",
+    });
     expect(adminMessages).toHaveLength(2); // flow 4 + flow 5
 
     // SSE: only 1 event (admin only, no assignee)
@@ -639,20 +612,14 @@ describe("flow 6: user preferences", () => {
     stack.events.reset();
 
     // Count messages before
-    const before = await db
-      .select()
-      .from(inAppMessagesTable)
-      .where(eq(inAppMessagesTable.userId, user1.id));
+    const before = await selectMany(db, inAppMessagesTable, { userId: user1.id });
     const beforeCount = before.length;
 
     // Send notification to user1 who has disabled inApp for orderAssigned
     await stack.http.writeOk("app:write:assign-order", { orderId: 99, driverId: user1.id }, admin);
 
     // No new InApp message for user1
-    const after = await db
-      .select()
-      .from(inAppMessagesTable)
-      .where(eq(inAppMessagesTable.userId, user1.id));
+    const after = await selectMany(db, inAppMessagesTable, { userId: user1.id });
     expect(after.length).toBe(beforeCount);
 
     // No SSE event
@@ -660,17 +627,12 @@ describe("flow 6: user preferences", () => {
     expect(notifs).toHaveLength(0);
 
     // DeliveryLog shows skipped with preference_disabled
-    const logs = await db
-      .select()
-      .from(deliveryAttemptsTable)
-      .where(
-        and(
-          eq(deliveryAttemptsTable.notificationType, "app:notify:order-assigned"),
-          eq(deliveryAttemptsTable.recipientId, user1.id),
-          eq(deliveryAttemptsTable.status, "skipped"),
-          eq(deliveryAttemptsTable.error, "preference_disabled"),
-        ),
-      );
+    const logs = await selectMany(db, deliveryAttemptsTable, {
+      notificationType: "app:notify:order-assigned",
+      recipientId: user1.id,
+      status: "skipped",
+      error: "preference_disabled",
+    });
     expect(logs.length).toBeGreaterThanOrEqual(1);
   });
 
@@ -816,10 +778,9 @@ describe("flow 9: email channel with renderer", () => {
   });
 
   test("delivery log has entries for both channels", async () => {
-    const logs = await db
-      .select()
-      .from(deliveryAttemptsTable)
-      .where(eq(deliveryAttemptsTable.notificationType, "tickets:notify:ticket-assigned"));
+    const logs = await selectMany(db, deliveryAttemptsTable, {
+      notificationType: "tickets:notify:ticket-assigned",
+    });
 
     const channels = logs.map((l) => l["channel"]);
     expect(channels).toContain("inApp");
@@ -862,15 +823,10 @@ describe("flow 10: complete end-to-end", () => {
     // --- InApp Channel ---
 
     // InApp message in DB with template-transformed data
-    const inAppMessages = await db
-      .select()
-      .from(inAppMessagesTable)
-      .where(
-        and(
-          eq(inAppMessagesTable.userId, user2.id),
-          eq(inAppMessagesTable.notificationType, "tickets:notify:ticket-assigned"),
-        ),
-      );
+    const inAppMessages = await selectMany(db, inAppMessagesTable, {
+      userId: user2.id,
+      notificationType: "tickets:notify:ticket-assigned",
+    });
     // Filter to this specific ticket by checking title
     const thisMessage = inAppMessages.find((m) =>
       (m["body"] as string)?.includes("Datenbank Backup"),
@@ -906,15 +862,10 @@ describe("flow 10: complete end-to-end", () => {
 
     // --- DeliveryLog ---
 
-    const logs = await db
-      .select()
-      .from(deliveryAttemptsTable)
-      .where(
-        and(
-          eq(deliveryAttemptsTable.notificationType, "tickets:notify:ticket-assigned"),
-          eq(deliveryAttemptsTable.recipientId, user2.id),
-        ),
-      );
+    const logs = await selectMany(db, deliveryAttemptsTable, {
+      notificationType: "tickets:notify:ticket-assigned",
+      recipientId: user2.id,
+    });
     // Filter to logs from this test (there may be prior entries)
     const inAppLog = logs.find((l) => l["channel"] === "inApp");
     const emailLog = logs.find((l) => l["channel"] === "email");
@@ -937,10 +888,9 @@ describe("flow 8: tenant broadcast via to: { tenant }", () => {
     );
 
     // All 3 tenant users get a message
-    const messages = await db
-      .select()
-      .from(inAppMessagesTable)
-      .where(eq(inAppMessagesTable.notificationType, "app:notify:tenant-alert"));
+    const messages = await selectMany(db, inAppMessagesTable, {
+      notificationType: "app:notify:tenant-alert",
+    });
     const recipientIds = messages.map((m) => m["userId"]);
     expect(recipientIds).toContain(admin.id);
     expect(recipientIds).toContain(user1.id);
@@ -960,10 +910,9 @@ describe("flow 8: tenant broadcast via to: { tenant }", () => {
   });
 
   test("delivery log has entries for all recipients and channels", async () => {
-    const logs = await db
-      .select()
-      .from(deliveryAttemptsTable)
-      .where(eq(deliveryAttemptsTable.notificationType, "app:notify:tenant-alert"));
+    const logs = await selectMany(db, deliveryAttemptsTable, {
+      notificationType: "app:notify:tenant-alert",
+    });
 
     // 3 users × 3 channels (inApp + email + push) = 9
     expect(logs).toHaveLength(9);
@@ -1001,17 +950,12 @@ describe("flow 12: rate limiting", () => {
     await stack.http.writeOk("app:write:assign-order", { orderId: 501, driverId: user1.id }, admin);
 
     // Email should be skipped (rate limited), but inApp + push should work
-    const emailLogs = await db
-      .select()
-      .from(deliveryAttemptsTable)
-      .where(
-        and(
-          eq(deliveryAttemptsTable.notificationType, "app:notify:order-assigned"),
-          eq(deliveryAttemptsTable.recipientId, user1.id),
-          eq(deliveryAttemptsTable.channel, "email"),
-          eq(deliveryAttemptsTable.error, "rate_limited"),
-        ),
-      );
+    const emailLogs = await selectMany(db, deliveryAttemptsTable, {
+      notificationType: "app:notify:order-assigned",
+      recipientId: user1.id,
+      channel: "email",
+      error: "rate_limited",
+    });
     expect(emailLogs.length).toBeGreaterThanOrEqual(1);
 
     // InApp still works
@@ -1107,15 +1051,10 @@ describe("flow 12c: idempotency key dedup", () => {
     expect(emails.length).toBe(1);
 
     // Dup attempt is recorded in the log for audit
-    const dupLogs = await db
-      .select()
-      .from(deliveryAttemptsTable)
-      .where(
-        and(
-          eq(deliveryAttemptsTable.notificationType, "app:notify:idem-test"),
-          eq(deliveryAttemptsTable.error, "duplicate_idempotency_key"),
-        ),
-      );
+    const dupLogs = await selectMany(db, deliveryAttemptsTable, {
+      notificationType: "app:notify:idem-test",
+      error: "duplicate_idempotency_key",
+    });
     expect(dupLogs.length).toBe(1);
   });
 
@@ -1162,17 +1101,12 @@ describe("flow 12d: channel error paths", () => {
     expect(emails.length).toBe(0);
 
     // Log shows the failure with the original error string
-    const failedLogs = await db
-      .select()
-      .from(deliveryAttemptsTable)
-      .where(
-        and(
-          eq(deliveryAttemptsTable.notificationType, "app:notify:order-assigned"),
-          eq(deliveryAttemptsTable.recipientId, user1.id),
-          eq(deliveryAttemptsTable.channel, "email"),
-          eq(deliveryAttemptsTable.status, "failed"),
-        ),
-      );
+    const failedLogs = await selectMany(db, deliveryAttemptsTable, {
+      notificationType: "app:notify:order-assigned",
+      recipientId: user1.id,
+      channel: "email",
+      status: "failed",
+    });
     expect(failedLogs.length).toBeGreaterThanOrEqual(1);
     expect(failedLogs.at(-1)?.["error"]).toContain("smtp_timeout_simulated");
 
@@ -1200,17 +1134,12 @@ describe("flow 12d: channel error paths", () => {
     );
     expect(broadcastEmails.length).toBe(1);
 
-    const failedLogs = await db
-      .select()
-      .from(deliveryAttemptsTable)
-      .where(
-        and(
-          eq(deliveryAttemptsTable.notificationType, "app:notify:announcement"),
-          eq(deliveryAttemptsTable.channel, "email"),
-          eq(deliveryAttemptsTable.status, "failed"),
-          eq(deliveryAttemptsTable.error, "smtp_transient"),
-        ),
-      );
+    const failedLogs = await selectMany(db, deliveryAttemptsTable, {
+      notificationType: "app:notify:announcement",
+      channel: "email",
+      status: "failed",
+      error: "smtp_transient",
+    });
     expect(failedLogs.length).toBe(1);
   });
 });
@@ -1232,17 +1161,12 @@ describe("flow 13: tenant kill switch", () => {
     expect(pushes).toHaveLength(0);
 
     // DeliveryLog shows channel_disabled
-    const pushLogs = await db
-      .select()
-      .from(deliveryAttemptsTable)
-      .where(
-        and(
-          eq(deliveryAttemptsTable.notificationType, "app:notify:order-assigned"),
-          eq(deliveryAttemptsTable.recipientId, user1.id),
-          eq(deliveryAttemptsTable.channel, "push"),
-          eq(deliveryAttemptsTable.error, "channel_disabled"),
-        ),
-      );
+    const pushLogs = await selectMany(db, deliveryAttemptsTable, {
+      notificationType: "app:notify:order-assigned",
+      recipientId: user1.id,
+      channel: "push",
+      error: "channel_disabled",
+    });
     expect(pushLogs.length).toBeGreaterThanOrEqual(1);
 
     // InApp + Email still work
@@ -1259,9 +1183,7 @@ describe("flow 13: tenant kill switch", () => {
 describe("flow 14: wildcard-only preference conflicts resolve deterministically", () => {
   test("conflicting wildcards (type=*, false vs channel=*, true) → disabled wins", async () => {
     // Clean slate for user2 on this type/channel
-    await db
-      .delete(notificationPreferencesTable)
-      .where(eq(notificationPreferencesTable.userId, user2.id));
+    await deleteMany(db, notificationPreferencesTable, { userId: user2.id });
 
     // Wildcard A: disable inApp globally
     await stack.http.writeOk(
@@ -1292,17 +1214,12 @@ describe("flow 14: wildcard-only preference conflicts resolve deterministically"
     const inAppEvents = stack.events.sse.filter((e) => e.type === "channel-in-app:event:delivered");
     expect(inAppEvents.filter((e) => e.data["userId"] === user2.id)).toHaveLength(0);
 
-    const skipped = await db
-      .select()
-      .from(deliveryAttemptsTable)
-      .where(
-        and(
-          eq(deliveryAttemptsTable.notificationType, "app:notify:wildcard-conflict"),
-          eq(deliveryAttemptsTable.recipientId, user2.id),
-          eq(deliveryAttemptsTable.channel, "inApp"),
-          eq(deliveryAttemptsTable.error, "preference_disabled"),
-        ),
-      );
+    const skipped = await selectMany(db, deliveryAttemptsTable, {
+      notificationType: "app:notify:wildcard-conflict",
+      recipientId: user2.id,
+      channel: "inApp",
+      error: "preference_disabled",
+    });
     expect(skipped.length).toBeGreaterThanOrEqual(1);
   });
 
@@ -1334,9 +1251,7 @@ describe("flow 14: wildcard-only preference conflicts resolve deterministically"
     expect(inAppEvents.filter((e) => e.data["userId"] === user2.id)).toHaveLength(1);
 
     // Clean up for later tests
-    await db
-      .delete(notificationPreferencesTable)
-      .where(eq(notificationPreferencesTable.userId, user2.id));
+    await deleteMany(db, notificationPreferencesTable, { userId: user2.id });
   });
 });
 
@@ -1395,16 +1310,11 @@ describe("flow 16: repeated unsubscribe clicks are idempotent", () => {
     }
 
     // Exactly one row exists, marked disabled
-    const rows = await db
-      .select()
-      .from(notificationPreferencesTable)
-      .where(
-        and(
-          eq(notificationPreferencesTable.userId, user1.id),
-          eq(notificationPreferencesTable.notificationType, "app:notify:concurrent-unsub"),
-          eq(notificationPreferencesTable.channel, "email"),
-        ),
-      );
+    const rows = await selectMany(db, notificationPreferencesTable, {
+      userId: user1.id,
+      notificationType: "app:notify:concurrent-unsub",
+      channel: "email",
+    });
     expect(rows).toHaveLength(1);
     expect(rows[0]?.["enabled"]).toBe(false);
   });

package/src/delivery/db/queries/preferences.ts

@@ -0,0 +1,30 @@
+import { asRawClient } from "@cosmicdrift/kumiko-framework/bun-db";
+import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
+import type { TenantId } from "@cosmicdrift/kumiko-framework/engine";
+
+export type NotificationPreferenceRow = {
+  readonly notificationType: string;
+  readonly channel: string;
+  readonly enabled: boolean;
+};
+
+export async function selectNotificationPreferences(
+  db: DbConnection,
+  tenantId: TenantId,
+  userId: string,
+  notificationType: string,
+  channelName: string,
+): Promise<readonly NotificationPreferenceRow[]> {
+  return asRawClient(db).unsafe<NotificationPreferenceRow>(
+    `SELECT notification_type AS "notificationType", channel, enabled
+     FROM read_notification_preferences
+     WHERE tenant_id = $1
+       AND user_id = $2
+       AND (
+         (notification_type = $3 AND channel = $4)
+         OR (notification_type = '*' AND channel = $4)
+         OR (notification_type = $3 AND channel = '*')
+       )`,
+    [tenantId, userId, notificationType, channelName],
+  );
+}

package/src/delivery/delivery-service.ts

@@ -7,11 +7,10 @@ import { append } from "@cosmicdrift/kumiko-framework/event-store";
 import { runProjectionsForEvent } from "@cosmicdrift/kumiko-framework/pipeline";
 import { bridgeStub } from "@cosmicdrift/kumiko-framework/testing/handler-context";
 import { generateId } from "@cosmicdrift/kumiko-framework/utils";
-import { and, eq, or } from "drizzle-orm";
 import type { Redis } from "ioredis";
 import { DELIVERY_ATTEMPT_EVENT } from "./constants";
+import { selectNotificationPreferences } from "./db/queries/preferences";
 import { deliveryAttemptSchema } from "./events";
-import { notificationPreferencesTable } from "./tables";
 import type {
   ChannelContext,
   ChannelMessage,
@@ -227,40 +226,13 @@ export function createDeliveryService(options: DeliveryServiceOptions): Delivery
     notificationType: string,
     channelName: string,
   ): Promise<boolean> {
-    type PrefRow = {
-      readonly notificationType: string;
-      readonly channel: string;
-      readonly enabled: boolean;
-    };
-    // Drizzle's dynamic-table select() loses column types; assert once at
-    // the boundary so the rest of this function works against a typed shape.
-    const prefs = (await db
-      .select({
-        notificationType: notificationPreferencesTable.notificationType,
-        channel: notificationPreferencesTable.channel,
-        enabled: notificationPreferencesTable.enabled,
-      })
-      .from(notificationPreferencesTable)
-      .where(
-        and(
-          eq(notificationPreferencesTable.tenantId, tenantId),
-          eq(notificationPreferencesTable.userId, userId),
-          or(
-            and(
-              eq(notificationPreferencesTable.notificationType, notificationType),
-              eq(notificationPreferencesTable.channel, channelName),
-            ),
-            and(
-              eq(notificationPreferencesTable.notificationType, "*"),
-              eq(notificationPreferencesTable.channel, channelName),
-            ),
-            and(
-              eq(notificationPreferencesTable.notificationType, notificationType),
-              eq(notificationPreferencesTable.channel, "*"),
-            ),
-          ),
-        ),
-      )) as readonly PrefRow[]; // @cast-boundary db-row
+    const prefs = await selectNotificationPreferences(
+      db,
+      tenantId,
+      userId,
+      notificationType,
+      channelName,
+    );
 
     if (prefs.length === 0) return true;
 

package/src/delivery/feature.ts

@@ -1,3 +1,4 @@
+import { insertOne } from "@cosmicdrift/kumiko-framework/bun-db";
 import { defineFeature, type FeatureDefinition } from "@cosmicdrift/kumiko-framework/engine";
 import type { z } from "zod";
 import { DELIVERY_ATTEMPT_EVENT } from "./constants";
@@ -34,7 +35,7 @@ export function createDeliveryFeature(): FeatureDefinition {
           const p = event.payload as z.infer<typeof deliveryAttemptSchema>; // @cast-boundary engine-payload
           // PK = aggregateId — replaying the same event twice conflicts on
           // the PK rather than silently duplicating the log row.
-          await tx.insert(deliveryAttemptsTable).values({
+          await insertOne(tx, deliveryAttemptsTable, {
             id: event.aggregateId,
             tenantId: event.tenantId,
             notificationType: p.notificationType,

package/src/delivery/handlers/log.query.ts

@@ -1,5 +1,5 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
 import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
-import { desc } from "drizzle-orm";
 import { z } from "zod";
 import { deliveryAttemptsTable } from "../tables";
 
@@ -10,12 +10,10 @@ export const logQuery = defineQueryHandler({
   }),
   access: { roles: ["Admin", "SystemAdmin"] },
   handler: async (query, ctx) => {
-    const rows = await ctx.db
-      .select()
-      .from(deliveryAttemptsTable)
-      .orderBy(desc(deliveryAttemptsTable.createdAt))
-      .limit(query.payload.limit);
-
+    const rows = await selectMany(ctx.db, deliveryAttemptsTable, undefined, {
+      orderBy: { col: "createdAt", direction: "desc" },
+      limit: query.payload.limit,
+    });
     return { rows };
   },
 });

package/src/delivery/handlers/preferences.query.ts

@@ -1,5 +1,5 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
 import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
-import { eq } from "drizzle-orm";
 import { z } from "zod";
 import { notificationPreferencesTable } from "../tables";
 
@@ -8,10 +8,7 @@ export const preferencesQuery = defineQueryHandler({
   schema: z.object({}),
   access: { openToAll: true },
   handler: async (query, ctx) => {
-    const rows = await ctx.db
-      .select()
-      .from(notificationPreferencesTable)
-      .where(eq(notificationPreferencesTable.userId, query.user.id));
+    const rows = await selectMany(ctx.db, notificationPreferencesTable, { userId: query.user.id });
 
     return { rows };
   },