@cosmicdrift/kumiko-bundled-features 0.1.0

package/src/channel-in-app/handlers/inbox.query.ts

@@ -0,0 +1,28 @@
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { and, desc, eq } from "drizzle-orm";
+import { z } from "zod";
+import { inAppMessagesTable } from "../tables";
+
+export const inboxQuery = defineQueryHandler({
+  name: "inbox",
+  schema: z.object({
+    limit: z.number().min(1).max(100).default(50),
+    unreadOnly: z.boolean().default(false),
+  }),
+  access: { openToAll: true },
+  handler: async (query, ctx) => {
+    const conditions = [eq(inAppMessagesTable.userId, query.user.id)];
+    if (query.payload.unreadOnly) {
+      conditions.push(eq(inAppMessagesTable.isRead, false));
+    }
+
+    const rows = await ctx.db
+      .select()
+      .from(inAppMessagesTable)
+      .where(and(...conditions))
+      .orderBy(desc(inAppMessagesTable.createdAt))
+      .limit(query.payload.limit);
+
+    return { rows };
+  },
+});

package/src/channel-in-app/handlers/mark-all-read.write.ts

@@ -0,0 +1,21 @@
+import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+import { inAppMessagesTable } from "../tables";
+
+export const markAllReadWrite = defineWriteHandler({
+  name: "markAllRead",
+  schema: z.object({}),
+  access: { openToAll: true },
+  handler: async (event, ctx) => {
+    const rows = await ctx.db
+      .update(inAppMessagesTable)
+      .set({ isRead: true, readAt: Temporal.Now.instant() })
+      .where(
+        and(eq(inAppMessagesTable.userId, event.user.id), eq(inAppMessagesTable.isRead, false)),
+      )
+      .returning();
+
+    return { isSuccess: true, data: { marked: rows.length } };
+  },
+});

package/src/channel-in-app/handlers/mark-read.write.ts

@@ -0,0 +1,32 @@
+import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { NotFoundError, writeFailure } from "@cosmicdrift/kumiko-framework/errors";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+import { inAppMessagesTable } from "../tables";
+
+export const markReadWrite = defineWriteHandler({
+  name: "markRead",
+  schema: z.object({
+    // inAppMessages.id is a serial integer (table is infra, not an ES aggregate).
+    id: z.number().int(),
+  }),
+  access: { openToAll: true },
+  handler: async (event, ctx) => {
+    const rows = await ctx.db
+      .update(inAppMessagesTable)
+      .set({ isRead: true, readAt: Temporal.Now.instant() })
+      .where(
+        and(
+          eq(inAppMessagesTable.id, event.payload.id),
+          eq(inAppMessagesTable.userId, event.user.id),
+        ),
+      )
+      .returning();
+
+    if (rows.length === 0) {
+      return writeFailure(new NotFoundError("inAppMessage", event.payload.id));
+    }
+
+    return { isSuccess: true, data: { id: rows[0]?.["id"] } };
+  },
+});

package/src/channel-in-app/handlers/unread-count.query.ts

@@ -0,0 +1,20 @@
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { and, count, eq } from "drizzle-orm";
+import { z } from "zod";
+import { inAppMessagesTable } from "../tables";
+
+export const unreadCountQuery = defineQueryHandler({
+  name: "unreadCount",
+  schema: z.object({}),
+  access: { openToAll: true },
+  handler: async (query, ctx) => {
+    const rows = await ctx.db
+      .select({ value: count() })
+      .from(inAppMessagesTable)
+      .where(
+        and(eq(inAppMessagesTable.userId, query.user.id), eq(inAppMessagesTable.isRead, false)),
+      );
+
+    return { count: rows[0]?.["value"] ?? 0 };
+  },
+});

package/src/channel-in-app/in-app-channel.ts

@@ -0,0 +1,44 @@
+import { tenantChannel } from "@cosmicdrift/kumiko-framework/engine";
+import type { DeliveryChannel } from "../delivery";
+import { inAppMessagesTable } from "./tables";
+
+export const inAppChannel: DeliveryChannel = {
+  name: "inApp",
+
+  async resolve(userId) {
+    // InApp always resolves — the userId IS the address
+    return String(userId);
+  },
+
+  async send(address, message, ctx) {
+    // address is the user-id string after the ES migration — keep it as-is.
+    const userId = address;
+
+    const rows = await ctx.db
+      .insert(inAppMessagesTable)
+      .values({
+        tenantId: ctx.tenantId,
+        userId,
+        notificationType: message.notificationType,
+        title: message.title,
+        body: message.body ?? null,
+        data: message.data ? JSON.stringify(message.data) : null,
+      })
+      .returning();
+
+    if (ctx.sseBroker) {
+      ctx.sseBroker.pushToChannel(tenantChannel(ctx.tenantId), {
+        type: "channel-in-app:event:delivered",
+        data: {
+          id: rows[0]?.["id"],
+          userId,
+          notificationType: message.notificationType,
+          title: message.title,
+          body: message.body,
+        },
+      });
+    }
+
+    return { status: "sent", address };
+  },
+};

package/src/channel-in-app/index.ts

@@ -0,0 +1,4 @@
+export { CHANNEL_IN_APP_FEATURE, InAppHandlers, InAppQueries } from "./constants";
+export { createChannelInAppFeature } from "./feature";
+export { inAppChannel } from "./in-app-channel";
+export { inAppMessagesTable } from "./tables";

package/src/channel-in-app/tables.ts

@@ -0,0 +1,22 @@
+import {
+  boolean,
+  instant,
+  table as pgTable,
+  serial,
+  text,
+  uuid,
+} from "@cosmicdrift/kumiko-framework/db";
+import { sql } from "drizzle-orm";
+
+export const inAppMessagesTable = pgTable("in_app_messages", {
+  id: serial("id").primaryKey(),
+  tenantId: uuid("tenant_id").notNull(),
+  userId: text("user_id").notNull(),
+  notificationType: text("notification_type").notNull(),
+  title: text("title").notNull(),
+  body: text("body"),
+  data: text("data"), // JSON string for action, screen, etc.
+  isRead: boolean("is_read").default(false).notNull(),
+  readAt: instant("read_at"),
+  createdAt: instant("created_at").default(sql`now()`).notNull(),
+});

package/src/channel-push/feature.ts

@@ -0,0 +1,15 @@
+import { defineFeature, type FeatureDefinition } from "@cosmicdrift/kumiko-framework/engine";
+import { createPushChannel, type PushChannelOptions } from "./push-channel";
+
+export function createChannelPushFeature(options: PushChannelOptions): FeatureDefinition {
+  const channel = createPushChannel(options);
+
+  return defineFeature("channelPush", (r) => {
+    r.requires("delivery");
+
+    r.useExtension("deliveryChannel", "push", {
+      resolve: channel.resolve,
+      send: channel.send,
+    });
+  });
+}

package/src/channel-push/index.ts

@@ -0,0 +1,3 @@
+export { createChannelPushFeature } from "./feature";
+export { createPushChannel, type PushChannelOptions } from "./push-channel";
+export { createInMemoryPushTransport, type PushMessage, type PushTransport } from "./types";

package/src/channel-push/push-channel.ts

@@ -0,0 +1,33 @@
+import type { TenantId } from "@cosmicdrift/kumiko-framework/engine";
+import type { DeliveryChannel } from "../delivery";
+import type { PushTransport } from "./types";
+
+export type PushChannelOptions = {
+  readonly transport: PushTransport;
+  readonly resolveToken: (
+    userId: string,
+    ctx: { db: unknown; tenantId: TenantId },
+  ) => Promise<string | null>;
+};
+
+export function createPushChannel(options: PushChannelOptions): DeliveryChannel {
+  const { transport, resolveToken } = options;
+
+  return {
+    name: "push",
+
+    async resolve(userId, ctx) {
+      return resolveToken(userId, ctx);
+    },
+
+    async send(address, message, _ctx) {
+      await transport.send({
+        token: address,
+        title: message.title,
+        body: message.body,
+        data: message.data,
+      });
+      return { status: "sent", address };
+    },
+  };
+}

package/src/channel-push/types.ts

@@ -0,0 +1,22 @@
+export type PushMessage = {
+  readonly token: string;
+  readonly title: string;
+  readonly body: string | undefined;
+  readonly data: Readonly<Record<string, unknown>> | undefined;
+};
+
+export type PushTransport = {
+  send(message: PushMessage): Promise<void>;
+};
+
+export function createInMemoryPushTransport(): PushTransport & {
+  readonly sent: PushMessage[];
+} {
+  const sent: PushMessage[] = [];
+  return {
+    sent,
+    async send(message) {
+      sent.push(message);
+    },
+  };
+}

package/src/config/__tests__/app-overrides.test.ts

@@ -0,0 +1,118 @@
+import { createTenantConfig, createUserConfig } from "@cosmicdrift/kumiko-framework/engine";
+import { describe, expect, test } from "vitest";
+import { validateAppOverrides } from "../resolver";
+
+// Minimal registry stub — validateAppOverrides only reads getConfigKey.
+// Cast keeps the test isolated from the rest of the Registry surface.
+function registryStub(keys: Record<string, unknown>) {
+  return {
+    getConfigKey: (key: string) => keys[key] as never,
+  };
+}
+
+describe("validateAppOverrides", () => {
+  test("accepts a typed override that matches an existing key", () => {
+    const reg = registryStub({
+      "files:config:max-size": createTenantConfig("number"),
+    });
+    const validated = validateAppOverrides(reg, {
+      "files:config:max-size": 50,
+    });
+    expect(validated.get("files:config:max-size")).toBe(50);
+    expect(validated.size).toBe(1);
+  });
+
+  test("throws on unknown key", () => {
+    const reg = registryStub({});
+    expect(() =>
+      validateAppOverrides(reg, {
+        "missing:config:x": 1,
+      }),
+    ).toThrow(/unknown config key.*missing:config:x/i);
+  });
+
+  test("throws on type mismatch — number key, string value", () => {
+    const reg = registryStub({
+      "a:config:x": createTenantConfig("number"),
+    });
+    expect(() =>
+      validateAppOverrides(reg, {
+        "a:config:x": "not-a-number",
+      }),
+    ).toThrow(/expected number, got string/i);
+  });
+
+  test("throws on type mismatch — boolean key, number value", () => {
+    const reg = registryStub({
+      "a:config:flag": createTenantConfig("boolean"),
+    });
+    expect(() =>
+      validateAppOverrides(reg, {
+        "a:config:flag": 1,
+      }),
+    ).toThrow(/expected boolean, got number/i);
+  });
+
+  test("select key — accepts value in options, rejects anything else", () => {
+    const reg = registryStub({
+      "a:config:theme": createTenantConfig("select", { options: ["light", "dark", "auto"] }),
+    });
+    // ok
+    expect(() => validateAppOverrides(reg, { "a:config:theme": "dark" })).not.toThrow();
+    // not in options
+    expect(() => validateAppOverrides(reg, { "a:config:theme": "purple" })).toThrow(
+      /not in options/i,
+    );
+  });
+
+  test("throws on bounds violation — below min", () => {
+    const reg = registryStub({
+      "a:config:n": createTenantConfig("number", { bounds: { min: 1, max: 100 } }),
+    });
+    expect(() => validateAppOverrides(reg, { "a:config:n": 0 })).toThrow(/below bounds\.min/i);
+  });
+
+  test("throws on bounds violation — above max", () => {
+    const reg = registryStub({
+      "a:config:n": createTenantConfig("number", { bounds: { min: 1, max: 100 } }),
+    });
+    expect(() => validateAppOverrides(reg, { "a:config:n": 101 })).toThrow(/above bounds\.max/i);
+  });
+
+  test("passes multiple overrides at once and preserves all", () => {
+    const reg = registryStub({
+      "a:config:n": createTenantConfig("number"),
+      "a:config:s": createTenantConfig("text"),
+      "a:config:b": createUserConfig("boolean"),
+    });
+    const result = validateAppOverrides(reg, {
+      "a:config:n": 42,
+      "a:config:s": "hello",
+      "a:config:b": true,
+    });
+    expect(result.size).toBe(3);
+    expect(result.get("a:config:n")).toBe(42);
+    expect(result.get("a:config:s")).toBe("hello");
+    expect(result.get("a:config:b")).toBe(true);
+  });
+
+  test("empty overrides map passes through without validation cost", () => {
+    const reg = registryStub({});
+    const result = validateAppOverrides(reg, {});
+    expect(result.size).toBe(0);
+  });
+
+  test("rejects override for a computed key — plan-logic may not be silently bypassed", () => {
+    const reg = registryStub({
+      "plan:config:quota": createTenantConfig("number", {
+        default: 10,
+        computed: async () => 100,
+      }),
+    });
+    expect(() =>
+      validateAppOverrides(reg, {
+        "plan:config:quota": 999,
+      }),
+    ).toThrow(/computed resolver.*app-overrides would silently bypass/i);
+  });
+});