@checkstack/notification-backend 0.0.2

package/src/schema.ts

@@ -0,0 +1,54 @@
+import {
+  pgTable,
+  text,
+  boolean,
+  uuid,
+  timestamp,
+  jsonb,
+  primaryKey,
+} from "drizzle-orm/pg-core";
+import type { NotificationAction } from "@checkstack/notification-common";
+
+// User notifications table
+export const notifications = pgTable("notifications", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  userId: text("user_id").notNull(), // No FK - cross-schema limitation
+  title: text("title").notNull(),
+  /** Notification body content (supports markdown) */
+  body: text("body").notNull(),
+  /** Single primary action button */
+  action: jsonb("action").$type<NotificationAction | null>(),
+  importance: text("importance").notNull().default("info"), // 'info' | 'warning' | 'critical'
+  isRead: boolean("is_read").notNull().default(false),
+  groupId: text("group_id"), // Namespaced: "pluginId.groupName"
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+});
+
+// Notification groups (created by plugins)
+// ID is namespaced: "pluginId.groupName"
+export const notificationGroups = pgTable("notification_groups", {
+  id: text("id").primaryKey(), // Namespaced: "pluginId.groupName"
+  name: text("name").notNull(),
+  description: text("description").notNull(),
+  ownerPlugin: text("owner_plugin").notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+});
+
+// User-group subscriptions
+export const notificationSubscriptions = pgTable(
+  "notification_subscriptions",
+  {
+    userId: text("user_id").notNull(),
+    groupId: text("group_id")
+      .notNull()
+      .references(() => notificationGroups.id, { onDelete: "cascade" }),
+    subscribedAt: timestamp("subscribed_at").defaultNow().notNull(),
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.userId, t.groupId] }),
+  })
+);
+
+// Note: User notification preferences are now stored via ConfigService
+// using the user-pref.{userId}.{strategyId} pattern for automatic
+// secret encryption of OAuth tokens.

package/src/service.ts

@@ -0,0 +1,216 @@
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { eq, and, count, desc, lt } from "drizzle-orm";
+import * as schema from "./schema";
+
+// --- Internal service functions for router (not namespaced) ---
+
+/**
+ * Get notifications for a user (for router use)
+ */
+export async function getUserNotifications(
+  db: NodePgDatabase<typeof schema>,
+  userId: string,
+  options: { limit: number; offset: number; unreadOnly: boolean }
+): Promise<{
+  notifications: (typeof schema.notifications.$inferSelect)[];
+  total: number;
+}> {
+  const conditions = [eq(schema.notifications.userId, userId)];
+
+  if (options.unreadOnly) {
+    conditions.push(eq(schema.notifications.isRead, false));
+  }
+
+  const whereClause = and(...conditions);
+
+  const [notificationsResult, countResult] = await Promise.all([
+    db
+      .select()
+      .from(schema.notifications)
+      .where(whereClause)
+      .orderBy(desc(schema.notifications.createdAt))
+      .limit(options.limit)
+      .offset(options.offset),
+    db.select({ count: count() }).from(schema.notifications).where(whereClause),
+  ]);
+
+  return {
+    notifications: notificationsResult,
+    total: countResult[0]?.count ?? 0,
+  };
+}
+
+/**
+ * Get unread count for a user
+ */
+export async function getUnreadCount(
+  db: NodePgDatabase<typeof schema>,
+  userId: string
+): Promise<number> {
+  const result = await db
+    .select({ count: count() })
+    .from(schema.notifications)
+    .where(
+      and(
+        eq(schema.notifications.userId, userId),
+        eq(schema.notifications.isRead, false)
+      )
+    );
+
+  return result[0]?.count ?? 0;
+}
+
+/**
+ * Mark notification(s) as read
+ */
+export async function markAsRead(
+  db: NodePgDatabase<typeof schema>,
+  userId: string,
+  notificationId?: string
+): Promise<void> {
+  const whereClause = notificationId
+    ? and(
+        eq(schema.notifications.id, notificationId),
+        eq(schema.notifications.userId, userId)
+      )
+    : eq(schema.notifications.userId, userId);
+
+  await db
+    .update(schema.notifications)
+    .set({ isRead: true })
+    .where(whereClause);
+}
+
+/**
+ * Delete a notification
+ */
+export async function deleteNotification(
+  db: NodePgDatabase<typeof schema>,
+  userId: string,
+  notificationId: string
+): Promise<void> {
+  await db
+    .delete(schema.notifications)
+    .where(
+      and(
+        eq(schema.notifications.id, notificationId),
+        eq(schema.notifications.userId, userId)
+      )
+    );
+}
+
+/**
+ * Get all notification groups
+ */
+export async function getAllGroups(
+  db: NodePgDatabase<typeof schema>
+): Promise<(typeof schema.notificationGroups.$inferSelect)[]> {
+  return db.select().from(schema.notificationGroups);
+}
+
+/**
+ * Get user's subscriptions with enriched group details
+ */
+export async function getEnrichedUserSubscriptions(
+  db: NodePgDatabase<typeof schema>,
+  userId: string
+): Promise<
+  {
+    groupId: string;
+    groupName: string;
+    groupDescription: string;
+    ownerPlugin: string;
+    subscribedAt: Date;
+  }[]
+> {
+  const result = await db
+    .select({
+      groupId: schema.notificationSubscriptions.groupId,
+      groupName: schema.notificationGroups.name,
+      groupDescription: schema.notificationGroups.description,
+      ownerPlugin: schema.notificationGroups.ownerPlugin,
+      subscribedAt: schema.notificationSubscriptions.subscribedAt,
+    })
+    .from(schema.notificationSubscriptions)
+    .innerJoin(
+      schema.notificationGroups,
+      eq(schema.notificationSubscriptions.groupId, schema.notificationGroups.id)
+    )
+    .where(eq(schema.notificationSubscriptions.userId, userId));
+
+  return result;
+}
+
+/**
+ * Subscribe user to a group
+ */
+export async function subscribeToGroup(
+  db: NodePgDatabase<typeof schema>,
+  userId: string,
+  groupId: string
+): Promise<void> {
+  // First verify the group exists
+  const group = await db
+    .select({ id: schema.notificationGroups.id })
+    .from(schema.notificationGroups)
+    .where(eq(schema.notificationGroups.id, groupId))
+    .limit(1);
+
+  if (group.length === 0) {
+    throw new Error(`Notification group '${groupId}' does not exist`);
+  }
+
+  await db
+    .insert(schema.notificationSubscriptions)
+    .values({
+      userId,
+      groupId,
+    })
+    .onConflictDoNothing();
+}
+
+/**
+ * Unsubscribe user from a group
+ */
+export async function unsubscribeFromGroup(
+  db: NodePgDatabase<typeof schema>,
+  userId: string,
+  groupId: string
+): Promise<void> {
+  await db
+    .delete(schema.notificationSubscriptions)
+    .where(
+      and(
+        eq(schema.notificationSubscriptions.userId, userId),
+        eq(schema.notificationSubscriptions.groupId, groupId)
+      )
+    );
+}
+
+/**
+ * Purge old notifications based on retention policy.
+ * Retention settings should be fetched from ConfigService and passed in.
+ */
+export async function purgeOldNotifications({
+  db,
+  enabled,
+  retentionDays,
+}: {
+  db: NodePgDatabase<typeof schema>;
+  enabled: boolean;
+  retentionDays: number;
+}): Promise<number> {
+  if (!enabled) {
+    return 0;
+  }
+
+  const cutoffDate = new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - retentionDays);
+
+  const result = await db
+    .delete(schema.notifications)
+    .where(lt(schema.notifications.createdAt, cutoffDate))
+    .returning({ id: schema.notifications.id });
+
+  return result.length;
+}