@goscribe/server 1.2.0 → 1.3.1

package/src/lib/notification-service.ts

@@ -0,0 +1,677 @@
+import PusherService from './pusher.js';
+
+type NotificationPriority = 'LOW' | 'NORMAL' | 'HIGH';
+
+export const NotificationType = {
+  GENERAL: 'GENERAL',
+  USER_SIGNED_UP: 'USER_SIGNED_UP',
+  ACCOUNT_DELETION_SCHEDULED: 'ACCOUNT_DELETION_SCHEDULED',
+  ACCOUNT_PERMANENTLY_DELETED: 'ACCOUNT_PERMANENTLY_DELETED',
+  WORKSPACE_INVITE_RECEIVED: 'WORKSPACE_INVITE_RECEIVED',
+  WORKSPACE_INVITE_ACCEPTED: 'WORKSPACE_INVITE_ACCEPTED',
+  WORKSPACE_DELETED: 'WORKSPACE_DELETED',
+  PAYMENT_SUCCEEDED: 'PAYMENT_SUCCEEDED',
+  SUBSCRIPTION_ACTIVATED: 'SUBSCRIPTION_ACTIVATED',
+  SUBSCRIPTION_PAYMENT_SUCCEEDED: 'SUBSCRIPTION_PAYMENT_SUCCEEDED',
+  SUBSCRIPTION_CANCELED: 'SUBSCRIPTION_CANCELED',
+  PAYMENT_FAILED: 'PAYMENT_FAILED',
+  WORKSPACE_ROLE_CHANGED: 'WORKSPACE_ROLE_CHANGED',
+  WORKSPACE_MEMBERSHIP_REMOVED: 'WORKSPACE_MEMBERSHIP_REMOVED',
+  STUDY_GUIDE_COMMENT_ADDED: 'STUDY_GUIDE_COMMENT_ADDED',
+  ARTIFACT_READY: 'ARTIFACT_READY',
+  ARTIFACT_FAILED: 'ARTIFACT_FAILED',
+} as const;
+
+export function artifactTypeLabel(artifactType: string): string {
+  const map: Record<string, string> = {
+    STUDY_GUIDE: 'Study guide',
+    FLASHCARD_SET: 'Flashcards',
+    WORKSHEET: 'Worksheet',
+    PODCAST_EPISODE: 'Podcast episode',
+    MEETING_SUMMARY: 'Meeting summary',
+  };
+  return map[artifactType] ?? artifactType;
+}
+
+export function buildArtifactActionUrl(
+  workspaceId: string,
+  artifactId: string | undefined,
+  artifactType: string,
+): string {
+  switch (artifactType) {
+    case 'STUDY_GUIDE':
+      return `/workspace/${workspaceId}/study-guide`;
+    case 'FLASHCARD_SET':
+      return `/workspace/${workspaceId}/flashcards`;
+    case 'WORKSHEET':
+      return artifactId
+        ? `/workspace/${workspaceId}/worksheet/${artifactId}`
+        : `/workspace/${workspaceId}/worksheet`;
+    case 'PODCAST_EPISODE':
+      return artifactId
+        ? `/workspace/${workspaceId}/podcasts/${artifactId}`
+        : `/workspace/${workspaceId}/podcasts`;
+    case 'MEETING_SUMMARY':
+      return `/workspace/${workspaceId}`;
+    default:
+      return `/workspace/${workspaceId}`;
+  }
+}
+
+function extractMentionEmails(text: string): string[] {
+  const re = /@([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/g;
+  const out: string[] = [];
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(text)) !== null) {
+    out.push(m[1].toLowerCase());
+  }
+  return [...new Set(out)];
+}
+
+async function resolveUserIdsByEmailsInWorkspace(
+  db: any,
+  workspaceId: string,
+  emails: string[],
+): Promise<string[]> {
+  if (!emails.length) return [];
+  const ids = new Set<string>();
+  for (const raw of emails) {
+    const user = await db.user.findFirst({
+      where: { email: { equals: raw, mode: 'insensitive' }, deletedAt: null },
+      select: { id: true },
+    });
+    if (!user) continue;
+    const member = await db.workspaceMember.findFirst({
+      where: { workspaceId, userId: user.id },
+      select: { id: true },
+    });
+    const owned = await db.workspace.findFirst({
+      where: { id: workspaceId, ownerId: user.id },
+      select: { id: true },
+    });
+    if (member || owned) ids.add(user.id);
+  }
+  return [...ids];
+}
+
+type CreateNotificationInput = {
+  userId: string;
+  type: string;
+  title: string;
+  body: string;
+  actorUserId?: string;
+  workspaceId?: string;
+  actionUrl?: string;
+  metadata?: Record<string, unknown>;
+  priority?: NotificationPriority;
+  sourceId?: string;
+};
+
+async function getUnreadCount(db: any, userId: string) {
+  return db.notification.count({
+    where: { userId, read: false },
+  });
+}
+
+export async function createNotification(db: any, input: CreateNotificationInput) {
+  if (input.sourceId) {
+    const existing = await db.notification.findFirst({
+      where: {
+        userId: input.userId,
+        type: input.type,
+        sourceId: input.sourceId,
+      },
+      // Avoid selecting all columns (including drifted optional columns) for idempotency check.
+      select: { id: true },
+    });
+
+    if (existing) {
+      return existing;
+    }
+  }
+
+  const created = await db.notification.create({
+    data: {
+      userId: input.userId,
+      actorUserId: input.actorUserId,
+      workspaceId: input.workspaceId,
+      type: input.type,
+      title: input.title,
+      body: input.body,
+      content: input.body,
+      actionUrl: input.actionUrl,
+      metadata: input.metadata,
+      priority: input.priority ?? 'NORMAL',
+      sourceId: input.sourceId,
+    },
+  });
+
+  const unreadCount = await getUnreadCount(db, input.userId);
+  await PusherService.emitNotificationNew(input.userId, {
+    notificationId: created.id,
+    type: created.type,
+    title: created.title,
+    unreadCount,
+    createdAt: created.createdAt.toISOString(),
+  });
+
+  return created;
+}
+
+export async function createManyNotifications(db: any, inputs: CreateNotificationInput[]) {
+  if (!inputs.length) return [];
+  const created = [];
+  for (const input of inputs) {
+    created.push(await createNotification(db, input));
+  }
+  return created;
+}
+
+export async function getSystemAdminIds(db: any) {
+  const admins = await db.user.findMany({
+    where: {
+      role: { name: 'System Admin' },
+      deletedAt: null,
+    },
+    select: { id: true },
+  });
+
+  return admins.map((admin: { id: string }) => admin.id);
+}
+
+export async function notifyAdminsOnSignup(db: any, user: { id: string; name?: string | null; email?: string | null }) {
+  const adminIds = await getSystemAdminIds(db);
+  if (!adminIds.length) return;
+
+  const displayName = user.name || user.email || 'New user';
+  await createManyNotifications(
+    db,
+    adminIds.map((adminId: string) => ({
+      userId: adminId,
+      actorUserId: user.id,
+      type: NotificationType.USER_SIGNED_UP,
+      title: 'New user signed up',
+      body: `${displayName} just created an account.`,
+      actionUrl: '/admin/users',
+      metadata: { newUserId: user.id, email: user.email },
+      sourceId: `signup:${user.id}`,
+      priority: 'NORMAL',
+    })),
+  );
+}
+
+export async function notifyAdminsAccountDeletionScheduled(
+  db: any,
+  user: { id: string; name?: string | null; email?: string | null },
+) {
+  const adminIds = await getSystemAdminIds(db);
+  const targets = adminIds.filter((id: string) => id !== user.id);
+  if (!targets.length) return;
+
+  const displayName = user.name || user.email || 'A user';
+  await createManyNotifications(
+    db,
+    targets.map((adminId: string) => ({
+      userId: adminId,
+      actorUserId: user.id,
+      type: NotificationType.ACCOUNT_DELETION_SCHEDULED,
+      title: `${displayName} scheduled account deletion`,
+      body: 'Their account will be permanently deleted after the grace period unless they restore it.',
+      actionUrl: '/admin/users',
+      metadata: { deletedUserId: user.id, email: user.email },
+      sourceId: `account-deletion-scheduled:${user.id}`,
+      priority: 'HIGH',
+    })),
+  );
+}
+
+export async function notifyAdminsAccountPermanentlyDeleted(
+  db: any,
+  user: { id: string; name?: string | null; email?: string | null },
+) {
+  const adminIds = await getSystemAdminIds(db);
+  const targets = adminIds.filter((id: string) => id !== user.id);
+  if (!targets.length) return;
+
+  const displayName = user.name || user.email || 'A user';
+  await createManyNotifications(
+    db,
+    targets.map((adminId: string) => ({
+      userId: adminId,
+      type: NotificationType.ACCOUNT_PERMANENTLY_DELETED,
+      title: `${displayName} permanently deleted`,
+      body: 'Their account and data have been removed after the grace period.',
+      actionUrl: '/admin/users',
+      metadata: { deletedUserId: user.id, email: user.email },
+      sourceId: `account-purged:${user.id}`,
+      priority: 'HIGH',
+    })),
+  );
+}
+
+export async function notifyInviteRecipient(db: any, input: {
+  invitedUserId: string;
+  inviterUserId: string;
+  workspaceId: string;
+  workspaceTitle: string;
+  invitationId: string;
+  invitationToken: string;
+  inviterName?: string | null;
+}) {
+  await createNotification(db, {
+    userId: input.invitedUserId,
+    actorUserId: input.inviterUserId,
+    workspaceId: input.workspaceId,
+    type: NotificationType.WORKSPACE_INVITE_RECEIVED,
+    title: 'Workspace invite received',
+    body: `${input.inviterName || 'A teammate'} invited you to join "${input.workspaceTitle}".`,
+    actionUrl: `/accept-invite?token=${encodeURIComponent(input.invitationToken)}`,
+    metadata: {
+      workspaceId: input.workspaceId,
+      workspaceName: input.workspaceTitle,
+      invitationId: input.invitationId,
+      inviterUserId: input.inviterUserId,
+    },
+    sourceId: `invite:${input.invitationId}`,
+  });
+}
+
+export async function notifyInviteAccepted(db: any, input: {
+  recipientUserIds: string[];
+  actorUserId: string;
+  workspaceId: string;
+  workspaceTitle: string;
+  memberName?: string | null;
+  invitationId: string;
+}) {
+  const uniqueRecipients = Array.from(new Set(input.recipientUserIds.filter(Boolean)));
+  await createManyNotifications(
+    db,
+    uniqueRecipients.map((userId) => ({
+      userId,
+      actorUserId: input.actorUserId,
+      workspaceId: input.workspaceId,
+      type: NotificationType.WORKSPACE_INVITE_ACCEPTED,
+      title: 'Workspace invite accepted',
+      body: `${input.memberName || 'A user'} joined "${input.workspaceTitle}".`,
+      actionUrl: `/workspace/${input.workspaceId}`,
+      metadata: {
+        workspaceId: input.workspaceId,
+        workspaceTitle: input.workspaceTitle,
+        invitationId: input.invitationId,
+      },
+      sourceId: `invite-accepted:${input.invitationId}:${userId}`,
+    })),
+  );
+}
+
+export async function notifyWorkspaceDeleted(db: any, input: {
+  recipientUserIds: string[];
+  actorUserId: string;
+  actorName: string;
+  workspaceId: string;
+  workspaceTitle: string;
+}) {
+  const uniqueRecipients = Array.from(
+    new Set(input.recipientUserIds.filter((id) => id && id !== input.actorUserId)),
+  );
+
+  if (!uniqueRecipients.length) return;
+
+  await createManyNotifications(
+    db,
+    uniqueRecipients.map((userId) => ({
+      userId,
+      actorUserId: input.actorUserId,
+      workspaceId: input.workspaceId,
+      type: NotificationType.WORKSPACE_DELETED,
+      title: `${input.actorName} deleted workspace`,
+      body: `"${input.workspaceTitle}" was deleted.`,
+      actionUrl: '/storage',
+      metadata: {
+        workspaceId: input.workspaceId,
+        workspaceTitle: input.workspaceTitle,
+        actorName: input.actorName,
+      },
+      sourceId: `workspace-deleted:${input.workspaceId}:${userId}`,
+      priority: 'HIGH',
+    })),
+  );
+}
+
+async function createBillingNotificationsForUserAndAdmins(
+  db: any,
+  input: Omit<CreateNotificationInput, 'userId'> & {
+    userId: string;
+    adminBody: string;
+    adminTitle?: string;
+  },
+) {
+  await createNotification(db, input);
+
+  const adminIds = await getSystemAdminIds(db);
+  const adminTargets = adminIds.filter((id: string) => id !== input.userId);
+  if (!adminTargets.length) return;
+
+  await createManyNotifications(
+    db,
+    adminTargets.map((adminId: string) => ({
+      userId: adminId,
+      actorUserId: input.userId,
+      workspaceId: input.workspaceId,
+      type: input.type,
+      title: input.adminTitle || input.title,
+      body: input.adminBody,
+      actionUrl: '/admin/users',
+      metadata: input.metadata,
+      priority: input.priority,
+      sourceId: input.sourceId ? `${input.sourceId}:admin:${adminId}` : undefined,
+    })),
+  );
+}
+
+export async function notifyPaymentSucceeded(db: any, input: {
+  userId: string;
+  planId?: string;
+  planName?: string;
+  stripeSessionId?: string;
+  amountPaid?: number;
+}) {
+  const planLabel = input.planName || 'selected plan';
+  await createBillingNotificationsForUserAndAdmins(db, {
+    userId: input.userId,
+    type: NotificationType.PAYMENT_SUCCEEDED,
+    title: 'Payment successful',
+    adminTitle: 'User payment successful',
+    body: `Your payment succeeded for ${planLabel}.`,
+    adminBody: `A user completed a successful payment for ${planLabel}.`,
+    actionUrl: '/settings',
+    metadata: {
+      planId: input.planId,
+      planName: input.planName,
+      stripeSessionId: input.stripeSessionId,
+      amountPaid: input.amountPaid,
+    },
+    sourceId: input.stripeSessionId ? `checkout:${input.stripeSessionId}` : undefined,
+  });
+}
+
+export async function notifySubscriptionActivated(db: any, input: {
+  userId: string;
+  planId?: string;
+  planName?: string;
+  stripeSubscriptionId: string;
+}) {
+  const planLabel = input.planName || 'your plan';
+  await createBillingNotificationsForUserAndAdmins(db, {
+    userId: input.userId,
+    type: NotificationType.SUBSCRIPTION_ACTIVATED,
+    title: `You subscribed to ${planLabel}`,
+    adminTitle: `User subscribed to ${planLabel}`,
+    body: `Your ${planLabel} subscription is active.`,
+    adminBody: `A user started a ${planLabel} subscription.`,
+    actionUrl: '/settings',
+    metadata: {
+      planId: input.planId,
+      planName: input.planName,
+      stripeSubscriptionId: input.stripeSubscriptionId,
+    },
+    sourceId: `subscription-created:${input.stripeSubscriptionId}`,
+  });
+}
+
+export async function notifySubscriptionPaymentSucceeded(db: any, input: {
+  userId: string;
+  planId?: string;
+  planName?: string;
+  stripeInvoiceId: string;
+  amountPaid?: number;
+}) {
+  const planLabel = input.planName || 'subscription';
+  await createBillingNotificationsForUserAndAdmins(db, {
+    userId: input.userId,
+    type: NotificationType.SUBSCRIPTION_PAYMENT_SUCCEEDED,
+    title: 'Subscription payment successful',
+    adminTitle: 'User subscription payment successful',
+    body: `Your ${planLabel} payment was successful.`,
+    adminBody: `A user successfully paid for ${planLabel}.`,
+    actionUrl: '/settings',
+    metadata: {
+      planId: input.planId,
+      planName: input.planName,
+      stripeInvoiceId: input.stripeInvoiceId,
+      amountPaid: input.amountPaid,
+    },
+    sourceId: `invoice-paid:${input.stripeInvoiceId}`,
+  });
+}
+
+export async function notifySubscriptionCanceled(db: any, input: {
+  userId: string;
+  planId?: string;
+  planName?: string;
+  stripeSubscriptionId: string;
+}) {
+  const planLabel = input.planName || 'subscription';
+  await createBillingNotificationsForUserAndAdmins(db, {
+    userId: input.userId,
+    type: NotificationType.SUBSCRIPTION_CANCELED,
+    title: 'Subscription canceled',
+    adminTitle: 'User subscription canceled',
+    body: `Your ${planLabel} subscription was canceled.`,
+    adminBody: `A user canceled ${planLabel}.`,
+    actionUrl: '/settings',
+    metadata: {
+      planId: input.planId,
+      planName: input.planName,
+      stripeSubscriptionId: input.stripeSubscriptionId,
+    },
+    sourceId: `subscription-canceled:${input.stripeSubscriptionId}`,
+    priority: 'HIGH',
+  });
+}
+
+export async function notifyPaymentFailed(db: any, input: {
+  userId: string;
+  planId?: string;
+  planName?: string;
+  stripeInvoiceId?: string;
+  stripePaymentIntentId?: string;
+}) {
+  const planLabel = input.planName || 'payment';
+  const sourceId = input.stripeInvoiceId
+    ? `invoice-failed:${input.stripeInvoiceId}`
+    : input.stripePaymentIntentId
+      ? `pi-failed:${input.stripePaymentIntentId}`
+      : undefined;
+
+  await createBillingNotificationsForUserAndAdmins(db, {
+    userId: input.userId,
+    type: NotificationType.PAYMENT_FAILED,
+    title: 'Payment failed',
+    adminTitle: 'User payment failed',
+    body: `Your ${planLabel} payment failed. Please update billing and retry.`,
+    adminBody: `A user payment failed for ${planLabel}.`,
+    actionUrl: '/settings',
+    metadata: {
+      planId: input.planId,
+      planName: input.planName,
+      stripeInvoiceId: input.stripeInvoiceId,
+      stripePaymentIntentId: input.stripePaymentIntentId,
+    },
+    sourceId,
+    priority: 'HIGH',
+  });
+}
+
+export async function notifyWorkspaceRoleChanged(
+  db: any,
+  input: {
+    memberUserId: string;
+    workspaceId: string;
+    workspaceTitle: string;
+    newRole: string;
+    oldRole: string;
+    actorUserId: string;
+    actorName: string;
+  },
+) {
+  const roleLabel = input.newRole === 'admin' ? 'admin' : 'member';
+  const oldLabel = input.oldRole === 'admin' ? 'admin' : 'member';
+  await createNotification(db, {
+    userId: input.memberUserId,
+    actorUserId: input.actorUserId,
+    workspaceId: input.workspaceId,
+    type: NotificationType.WORKSPACE_ROLE_CHANGED,
+    title: `Your role in "${input.workspaceTitle}" changed`,
+    body: `${input.actorName} changed your role from ${oldLabel} to ${roleLabel}.`,
+    actionUrl: `/workspace/${input.workspaceId}/members`,
+    metadata: {
+      oldRole: input.oldRole,
+      newRole: input.newRole,
+      workspaceTitle: input.workspaceTitle,
+    },
+    priority: 'NORMAL',
+  });
+}
+
+export async function notifyWorkspaceMembershipRemoved(
+  db: any,
+  input: {
+    memberUserId: string;
+    workspaceId: string;
+    workspaceTitle: string;
+    actorUserId: string;
+    actorName: string;
+  },
+) {
+  await createNotification(db, {
+    userId: input.memberUserId,
+    actorUserId: input.actorUserId,
+    workspaceId: input.workspaceId,
+    type: NotificationType.WORKSPACE_MEMBERSHIP_REMOVED,
+    title: `Removed from "${input.workspaceTitle}"`,
+    body: `${input.actorName} removed you from this workspace.`,
+    actionUrl: '/storage',
+    metadata: { workspaceTitle: input.workspaceTitle },
+    priority: 'HIGH',
+  });
+}
+
+export async function notifyStudyGuideCommentAdded(
+  db: any,
+  input: {
+    authorUserId: string;
+    authorName: string;
+    content: string;
+    highlightId: string;
+    commentId: string;
+    workspaceId: string;
+    artifactId: string;
+    artifactTitle: string;
+    recipientUserIds: string[];
+  },
+) {
+  const mentionEmails = extractMentionEmails(input.content);
+  const mentionUserIds = await resolveUserIdsByEmailsInWorkspace(
+    db,
+    input.workspaceId,
+    mentionEmails,
+  );
+  const combined = new Set<string>([
+    ...input.recipientUserIds.filter(Boolean),
+    ...mentionUserIds,
+  ]);
+  combined.delete(input.authorUserId);
+  const targets = [...combined];
+  if (!targets.length) return;
+
+  const preview =
+    input.content.length > 140
+      ? `${input.content.slice(0, 137)}...`
+      : input.content;
+
+  await createManyNotifications(
+    db,
+    targets.map((userId) => ({
+      userId,
+      actorUserId: input.authorUserId,
+      workspaceId: input.workspaceId,
+      type: NotificationType.STUDY_GUIDE_COMMENT_ADDED,
+      title: `${input.authorName} commented on "${input.artifactTitle}"`,
+      body: preview,
+      actionUrl: `/workspace/${input.workspaceId}/study-guide`,
+      metadata: {
+        artifactId: input.artifactId,
+        highlightId: input.highlightId,
+        commentId: input.commentId,
+      },
+      sourceId: `comment:${input.commentId}:${userId}`,
+    })),
+  );
+}
+
+export async function notifyArtifactReady(
+  db: any,
+  input: {
+    userId: string;
+    workspaceId: string;
+    artifactId: string;
+    artifactType: string;
+    title: string;
+  },
+) {
+  const kind = artifactTypeLabel(input.artifactType);
+  await createNotification(db, {
+    userId: input.userId,
+    workspaceId: input.workspaceId,
+    type: NotificationType.ARTIFACT_READY,
+    title: `${kind} ready`,
+    body: `"${input.title}" is ready to open.`,
+    actionUrl: buildArtifactActionUrl(
+      input.workspaceId,
+      input.artifactId,
+      input.artifactType,
+    ),
+    metadata: {
+      artifactId: input.artifactId,
+      artifactType: input.artifactType,
+    },
+    sourceId: `artifact-ready:${input.artifactId}`,
+    priority: 'NORMAL',
+  });
+}
+
+export async function notifyArtifactFailed(
+  db: any,
+  input: {
+    userId: string;
+    workspaceId: string;
+    artifactType: string;
+    title?: string;
+    artifactId?: string;
+    message: string;
+  },
+) {
+  const kind = artifactTypeLabel(input.artifactType);
+  await createNotification(db, {
+    userId: input.userId,
+    workspaceId: input.workspaceId,
+    type: NotificationType.ARTIFACT_FAILED,
+    title: `${kind} generation failed`,
+    body: input.message,
+    actionUrl: buildArtifactActionUrl(
+      input.workspaceId,
+      input.artifactId,
+      input.artifactType,
+    ),
+    metadata: {
+      artifactId: input.artifactId,
+      artifactType: input.artifactType,
+    },
+    sourceId: input.artifactId
+      ? `artifact-failed:${input.artifactId}`
+      : undefined,
+    priority: 'HIGH',
+  });
+}

package/src/lib/prisma.ts

@@ -1,4 +1,9 @@
-import { PrismaClient } from "@prisma/client";
+// Resolve the client from this package's generated output so types always match
+// `prisma/schema.prisma` (the `@prisma/client` entry can resolve to a different
+// generated client in multi-folder workspaces and lose model delegates in the IDE).
+import { PrismaClient } from "../../node_modules/.prisma/client/index.js";
+
+export { ArtifactType } from "../../node_modules/.prisma/client/index.js";
 
 const globalForPrisma = globalThis as unknown as { prisma?: PrismaClient };