@actuate-media/cms-admin 0.12.0 → 0.12.1

package/src/lib/notifications-client.ts

@@ -0,0 +1,146 @@
+/**
+ * Notifications REST client — typed wrapper around the slice-6 endpoints
+ * (`/notifications`, `/notifications/unread-count`,
+ * `/notifications/:id/read`, `/notifications/read-all`).
+ *
+ * Lives in `cms-admin` so the bell, the toast layer, and any future
+ * background sync agent share one request path, error model, and DTO
+ * shape. The wire format mirrors `NotificationDTO` in
+ * `@actuate-media/cms-core/realtime/notifications.ts`; we duplicate the
+ * shape here to avoid taking a hard dependency on the server module
+ * (which carries Prisma types that don't belong in the admin bundle).
+ */
+
+import { cmsApi } from './api.js'
+
+export type NotificationKind = 'comment_reply' | 'comment_resolved' | 'comment_mention'
+
+export interface CommentReplyPayload {
+  kind: 'comment_reply'
+  actorId: string | null
+  actorName: string | null
+  excerpt: string
+}
+
+export interface CommentResolvedPayload {
+  kind: 'comment_resolved'
+  actorId: string | null
+  actorName: string | null
+  rootExcerpt: string
+}
+
+export interface CommentMentionPayload {
+  kind: 'comment_mention'
+  actorId: string | null
+  actorName: string | null
+  excerpt: string
+}
+
+export type NotificationPayload =
+  | CommentReplyPayload
+  | CommentResolvedPayload
+  | CommentMentionPayload
+
+export interface Notification {
+  id: string
+  userId: string
+  kind: NotificationKind
+  documentId: string | null
+  commentId: string | null
+  payload: NotificationPayload
+  readAt: string | null
+  createdAt: string
+}
+
+export type NotificationOutcome<T> =
+  | { ok: true; result: T }
+  | { ok: false; error: string; status: number }
+
+export interface ListNotificationsOptions {
+  /** Default: false. When true the response includes already-read rows. */
+  includeRead?: boolean
+  /** Default: server-side cap. Hard upper bound is 200. */
+  pageSize?: number
+}
+
+function failure(error: string, status: number): { ok: false; error: string; status: number } {
+  return { ok: false, error, status }
+}
+
+function envelope<T>(res: {
+  data?: unknown
+  error?: string
+  status: number
+}): NotificationOutcome<T> {
+  if (res.error || res.data === undefined) {
+    return failure(res.error ?? `Request failed (${res.status})`, res.status)
+  }
+  return { ok: true, result: res.data as T }
+}
+
+function buildQuery(opts: ListNotificationsOptions = {}): string {
+  const params = new URLSearchParams()
+  if (opts.includeRead) params.set('includeRead', 'true')
+  if (opts.pageSize !== undefined) params.set('pageSize', String(opts.pageSize))
+  const qs = params.toString()
+  return qs ? `?${qs}` : ''
+}
+
+export async function listNotifications(
+  opts: ListNotificationsOptions = {},
+): Promise<NotificationOutcome<Notification[]>> {
+  const res = await cmsApi<Notification[]>(`/notifications${buildQuery(opts)}`, {
+    method: 'GET',
+  })
+  return envelope<Notification[]>(res)
+}
+
+export async function unreadCount(): Promise<NotificationOutcome<number>> {
+  const res = await cmsApi<{ count: number }>(`/notifications/unread-count`, {
+    method: 'GET',
+  })
+  if (res.error || !res.data) {
+    return failure(res.error ?? `Request failed (${res.status})`, res.status)
+  }
+  return { ok: true, result: res.data.count }
+}
+
+export async function markNotificationRead(id: string): Promise<NotificationOutcome<Notification>> {
+  if (!id) return failure('notification id is required', 0)
+  const res = await cmsApi<Notification>(`/notifications/${encodeURIComponent(id)}/read`, {
+    method: 'POST',
+    body: '{}',
+  })
+  return envelope<Notification>(res)
+}
+
+export async function markAllNotificationsRead(): Promise<NotificationOutcome<number>> {
+  const res = await cmsApi<{ count: number }>(`/notifications/read-all`, {
+    method: 'POST',
+    body: '{}',
+  })
+  if (res.error || !res.data) {
+    return failure(res.error ?? `Request failed (${res.status})`, res.status)
+  }
+  return { ok: true, result: res.data.count }
+}
+
+/**
+ * Cheap single-line summary for the bell list — the server gives us a
+ * structured payload, but the dropdown wants one human-readable string
+ * per row. Falls back to `Notification` when an unknown kind sneaks in
+ * (defensive against future server-side additions).
+ */
+export function notificationSummary(notification: Notification): string {
+  const actor = notification.payload.actorName ?? 'Someone'
+  switch (notification.payload.kind) {
+    case 'comment_reply':
+      return `${actor} replied: "${notification.payload.excerpt}"`
+    case 'comment_resolved':
+      return `${actor} resolved your thread: "${notification.payload.rootExcerpt}"`
+    case 'comment_mention':
+      return `${actor} mentioned you: "${notification.payload.excerpt}"`
+    default:
+      return 'Notification'
+  }
+}

package/src/lib/slash-command.ts

@@ -0,0 +1,67 @@
+import { COAUTHOR_ACTIONS, isCoauthorAction, type CoauthorAction } from './coauthor-client.js'
+
+/**
+ * Cmd+K slash-command parsing for the AI co-author.
+ *
+ * Recognized syntax (case-insensitive, leading whitespace tolerated):
+ *
+ *     /ai <action> [text...]
+ *
+ * `<action>` is one of `COAUTHOR_ACTIONS`. `text` is the payload handed to
+ * `/ai/coauthor`; it may be empty while the user is still typing.
+ *
+ * The parser is pure so we can unit-test every edge case (case folding,
+ * trailing whitespace, partial input, unknown actions) without spinning up
+ * `cmdk` or the rest of the palette.
+ */
+
+export interface AiSlashCommand {
+  action: CoauthorAction
+  text: string
+}
+
+const SLASH_HEAD = /^\s*\/\s*ai(?:\s+|$)/i
+
+/**
+ * Returns the matched `{ action, text }` when `input` is a complete
+ * slash command (`/ai rewrite ...`), or `null` otherwise. `text` may be
+ * empty when the user has typed `/ai rewrite` with no payload yet.
+ */
+export function parseAiSlashCommand(input: string): AiSlashCommand | null {
+  if (typeof input !== 'string') return null
+  if (!SLASH_HEAD.test(input)) return null
+  const after = input.replace(SLASH_HEAD, '')
+  if (after.length === 0) return null
+
+  const firstWhitespace = after.search(/\s/)
+  const head = (firstWhitespace === -1 ? after : after.slice(0, firstWhitespace)).toLowerCase()
+  if (!isCoauthorAction(head)) return null
+
+  const tail = firstWhitespace === -1 ? '' : after.slice(firstWhitespace + 1)
+  return { action: head, text: tail.trim() }
+}
+
+/**
+ * Returns true when `input` looks like the start of an AI slash command
+ * — even when the action isn't typed yet (`/`, `/a`, `/ai`, `/ai re`).
+ * The palette uses this to switch into "AI mode" (hide nav results,
+ * show the four action suggestions).
+ */
+export function isAiSlashCommandInput(input: string): boolean {
+  if (typeof input !== 'string') return false
+  const trimmed = input.trim()
+  if (trimmed.length === 0) return false
+  if (trimmed === '/') return true
+  return /^\/\s*a(i\b|i?[a-z]*|)?(\s.*)?$/i.test(trimmed)
+}
+
+/**
+ * Ordered list of actions to show in AI mode. When the user has typed a
+ * valid command, that command's action is hoisted to the top so it gets
+ * the default keyboard focus (and Enter runs it).
+ */
+export function orderedAiActions(input: string): CoauthorAction[] {
+  const parsed = parseAiSlashCommand(input)
+  if (!parsed) return [...COAUTHOR_ACTIONS]
+  return [parsed.action, ...COAUTHOR_ACTIONS.filter((a) => a !== parsed.action)]
+}