experimental-a2 0.20.0 → 0.22.0

package/examples/playground/app/a2slack/db/migrations/meta/_journal.json

@@ -0,0 +1,41 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1792155179052,
+      "tag": "0000_extensions",
+      "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1792155179654,
+      "tag": "0001_workspace",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "7",
+      "when": 1792182002919,
+      "tag": "0002_a2",
+      "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "7",
+      "when": 1792282388330,
+      "tag": "0003_a2_batch",
+      "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "7",
+      "when": 1792693132589,
+      "tag": "0004_a2_session_event_ids",
+      "breakpoints": true
+    }
+  ]
+}

package/examples/playground/app/a2slack/db/queries.ts

@@ -0,0 +1,263 @@
+/**
+ * Every read a2slack makes. Each one runs in a single repeatable-read
+ * transaction with the feed consumer's position, so the rows it returns are
+ * exactly the log through `through`: the client applies the events after it
+ * (model.ts) and misses nothing, twice or not at all.
+ */
+import 'server-only'
+import {
+  and,
+  asc,
+  count,
+  desc,
+  eq,
+  gt,
+  ilike,
+  inArray,
+  isNull,
+  lt,
+  max,
+  sql,
+} from 'drizzle-orm'
+import type {
+  ChatMessage,
+  InboxPage,
+  MessagePage,
+  Reason,
+  SearchResult,
+  ThreadPage,
+} from '../model'
+import { database, type Db } from '.'
+import {
+  channels,
+  messages,
+  notifications,
+  positions,
+  reactions,
+  reads,
+} from './schema'
+
+/** The feed consumer's name, which its position is recorded under. */
+export const FEED = 'a2slack-feed'
+
+export const PAGE_SIZE = 50
+
+type Tx = Parameters<Parameters<Db['transaction']>[0]>[0]
+
+const snapshot = <T>(read: (tx: Tx) => Promise<T>): Promise<T> =>
+  database().then((db) =>
+    db.transaction(read, { isolationLevel: 'repeatable read' }),
+  )
+
+/** How far `consumer` has read the log: the last event it applied, or 0. */
+export async function position(db: Db, consumer: string): Promise<number> {
+  const [row] = await db
+    .select({ logIndex: positions.logIndex })
+    .from(positions)
+    .where(eq(positions.consumer, consumer))
+  return row?.logIndex ?? 0
+}
+
+/** The channel list, as of `through`: `channelsReducer`'s state. */
+export const workspaceSnapshot = (): Promise<{
+  channels: string[]
+  opened: Record<string, number>
+  through: number
+}> =>
+  snapshot(async (tx) => {
+    const through = await position(tx, FEED)
+    const rows = await tx
+      .select({ id: channels.id, logIndex: channels.logIndex })
+      .from(channels)
+      .orderBy(asc(channels.logIndex))
+    return {
+      channels: rows.map((row) => row.id),
+      opened: Object.fromEntries(rows.map((row) => [row.id, row.logIndex])),
+      through,
+    }
+  })
+
+type MessageRow = typeof messages.$inferSelect
+
+/** Rows as the client renders them: reactions, reply counts, and labels in place. */
+async function hydrate(tx: Tx, rows: MessageRow[]): Promise<ChatMessage[]> {
+  if (rows.length === 0) return []
+  const ids = rows.map((row) => row.id)
+  const [reacted, replied] = await Promise.all([
+    tx
+      .select()
+      .from(reactions)
+      .where(inArray(reactions.messageId, ids))
+      .orderBy(asc(reactions.logIndex)),
+    tx
+      .select({
+        threadId: messages.threadId,
+        replies: count(),
+        last: max(messages.postedAt),
+      })
+      .from(messages)
+      .where(inArray(messages.threadId, ids))
+      .groupBy(messages.threadId),
+  ])
+  return rows.map((row) => {
+    const message: ChatMessage = {
+      id: row.id,
+      index: row.logIndex,
+      channel: row.channel,
+      author: { id: row.authorId, name: row.authorName },
+      text: row.text,
+      at: row.postedAt.toISOString(),
+      reactions: [],
+      replyCount: 0,
+    }
+    if (row.editedAt) message.editedAt = row.editedAt.toISOString()
+    if (row.deleted) message.deleted = true
+    if (row.threadId !== null) message.threadId = row.threadId
+    if (row.label !== null) message.label = row.label as ChatMessage['label']
+    if (!row.deleted) {
+      for (const reaction of reacted) {
+        if (reaction.messageId !== row.id) continue
+        const by = { id: reaction.authorId, name: reaction.authorName }
+        const existing = message.reactions.find(
+          (r) => r.emoji === reaction.emoji,
+        )
+        if (existing) existing.by.push(by)
+        else message.reactions.push({ emoji: reaction.emoji, by: [by] })
+      }
+    }
+    const thread = replied.find((reply) => reply.threadId === row.id)
+    if (thread) {
+      message.replyCount = thread.replies
+      if (thread.last) message.lastReplyAt = new Date(thread.last).toISOString()
+    }
+    return message
+  })
+}
+
+/** A channel's newest top-level messages, or those before log index `before`. */
+export const messagePage = (
+  channel: string,
+  { before }: { before?: number } = {},
+): Promise<MessagePage> =>
+  snapshot(async (tx) => {
+    const through = await position(tx, FEED)
+    const rows = await tx
+      .select()
+      .from(messages)
+      .where(
+        and(
+          eq(messages.channel, channel),
+          isNull(messages.threadId),
+          before === undefined ? undefined : lt(messages.logIndex, before),
+        ),
+      )
+      .orderBy(desc(messages.logIndex))
+      .limit(PAGE_SIZE + 1)
+    const page = rows.slice(0, PAGE_SIZE).toReversed()
+    return {
+      messages: await hydrate(tx, page),
+      through,
+      more: rows.length > PAGE_SIZE,
+    }
+  })
+
+/** A thread's root and every reply. */
+export const threadPage = (rootId: string): Promise<ThreadPage> =>
+  snapshot(async (tx) => {
+    const through = await position(tx, FEED)
+    const [root] = await tx
+      .select()
+      .from(messages)
+      .where(eq(messages.id, rootId))
+    const replies = await tx
+      .select()
+      .from(messages)
+      .where(eq(messages.threadId, rootId))
+      .orderBy(asc(messages.logIndex))
+    const [hydratedRoot] = root ? await hydrate(tx, [root]) : [null]
+    return {
+      root: hydratedRoot ?? null,
+      replies: await hydrate(tx, replies),
+      through,
+    }
+  })
+
+/** Someone's inbox: each thread's latest notification and its unread count. */
+export const inboxPage = (userId: string): Promise<InboxPage> =>
+  snapshot(async (tx) => {
+    const through = await position(tx, FEED)
+    const [latest, unread] = await Promise.all([
+      tx
+        .selectDistinctOn([notifications.threadId])
+        .from(notifications)
+        .where(eq(notifications.userId, userId))
+        .orderBy(notifications.threadId, desc(notifications.logIndex)),
+      tx
+        .select({ threadId: notifications.threadId, unread: count() })
+        .from(notifications)
+        .leftJoin(
+          reads,
+          and(
+            eq(reads.userId, notifications.userId),
+            eq(reads.threadId, notifications.threadId),
+          ),
+        )
+        .where(
+          and(
+            eq(notifications.userId, userId),
+            gt(notifications.logIndex, sql`coalesce(${reads.through}, 0)`),
+          ),
+        )
+        .groupBy(notifications.threadId),
+    ])
+    const items = latest
+      .toSorted((a, b) => b.logIndex - a.logIndex)
+      .slice(0, PAGE_SIZE)
+      .map((row) => ({
+        threadId: row.threadId,
+        channel: row.channel,
+        reason: row.reason as Reason,
+        from: { id: row.fromId, name: row.fromName },
+        text: row.text,
+        messageId: row.messageId,
+        at: row.sentAt.toISOString(),
+        index: row.logIndex,
+        unread:
+          unread.find((thread) => thread.threadId === row.threadId)?.unread ??
+          0,
+      }))
+    return { items, through }
+  })
+
+/** Escapes LIKE's wildcards, so a query matches its own characters. */
+const literal = (text: string): string => text.replaceAll(/[\\%_]/g, '\\$&')
+
+/**
+ * The newest messages, across every channel, whose text contains `q`: search
+ * where Redis Search isn't configured.
+ */
+export async function searchFeed(
+  q: string,
+  limit = PAGE_SIZE,
+): Promise<SearchResult[]> {
+  const db = await database()
+  const rows = await db
+    .select()
+    .from(messages)
+    .where(
+      and(eq(messages.deleted, false), ilike(messages.text, `%${literal(q)}%`)),
+    )
+    .orderBy(desc(messages.logIndex))
+    .limit(limit)
+  return rows.map((row) => {
+    const result: SearchResult = {
+      channel: row.channel,
+      id: row.id,
+      author: { id: row.authorId, name: row.authorName },
+      text: row.text,
+      at: row.postedAt.toISOString(),
+    }
+    if (row.threadId !== null) result.threadId = row.threadId
+    return result
+  })
+}

package/examples/playground/app/a2slack/db/schema.ts

@@ -0,0 +1,145 @@
+/**
+ * a2slack's tables. A2's log is the source of truth; these hold what the app
+ * reads, built from the log by consumers (consumers/). Change them here, then
+ * `pnpm db:generate` writes the migration into ./migrations.
+ */
+import {
+  bigint,
+  boolean,
+  index,
+  pgTable,
+  primaryKey,
+  text,
+  timestamp,
+} from 'drizzle-orm/pg-core'
+
+const logIndex = () => bigint({ mode: 'number' }).notNull()
+const at = () => timestamp({ withTimezone: true }).notNull()
+
+/** How far each consumer that keeps tables here has read the log. */
+export const positions = pgTable('a2slack_positions', {
+  consumer: text().primaryKey(),
+  logIndex: logIndex(),
+})
+
+// ── The feed consumer's tables: everything a page shows. ──────────────
+
+export const channels = pgTable('a2slack_channels', {
+  id: text().primaryKey(),
+  createdByName: text().notNull(),
+  createdAt: at(),
+  logIndex: logIndex(),
+})
+
+export const messages = pgTable(
+  'a2slack_messages',
+  {
+    id: text().primaryKey(),
+    channel: text().notNull(),
+    /** The message's position in the workspace's A2 log. */
+    logIndex: logIndex(),
+    threadId: text(),
+    authorId: text().notNull(),
+    authorName: text().notNull(),
+    text: text().notNull(),
+    postedAt: at(),
+    editedAt: timestamp({ withTimezone: true }),
+    deleted: boolean().notNull().default(false),
+    label: text(),
+  },
+  (table) => [
+    // A channel's top-level messages, and a thread's replies, in log order.
+    index('a2slack_messages_feed').on(
+      table.channel,
+      table.threadId,
+      table.logIndex,
+    ),
+    index('a2slack_messages_thread').on(table.threadId, table.logIndex),
+    // Substring search (`ilike '%…%'`) without a scan, where Redis Search
+    // isn't configured.
+    index('a2slack_messages_text_trgm').using(
+      'gin',
+      table.text.op('gin_trgm_ops'),
+    ),
+  ],
+)
+
+export const reactions = pgTable(
+  'a2slack_reactions',
+  {
+    messageId: text().notNull(),
+    emoji: text().notNull(),
+    authorId: text().notNull(),
+    authorName: text().notNull(),
+    logIndex: logIndex(),
+  },
+  (table) => [
+    primaryKey({ columns: [table.messageId, table.emoji, table.authorId] }),
+  ],
+)
+
+/** Every notification, one row each; the inbox groups them by thread. */
+export const notifications = pgTable(
+  'a2slack_notifications',
+  {
+    id: text().primaryKey(),
+    userId: text().notNull(),
+    threadId: text().notNull(),
+    channel: text().notNull(),
+    reason: text().notNull(),
+    messageId: text().notNull(),
+    fromId: text().notNull(),
+    fromName: text().notNull(),
+    text: text().notNull(),
+    logIndex: logIndex(),
+    sentAt: at(),
+  },
+  (table) => [
+    index('a2slack_notifications_inbox').on(
+      table.userId,
+      table.threadId,
+      table.logIndex,
+    ),
+  ],
+)
+
+/** How far someone has read each thread's notifications. */
+export const reads = pgTable(
+  'a2slack_reads',
+  {
+    userId: text().notNull(),
+    threadId: text().notNull(),
+    through: logIndex(),
+  },
+  (table) => [primaryKey({ columns: [table.userId, table.threadId] })],
+)
+
+// ── The notify consumer's tables: who to tell. ────────────────────────
+
+/** Everyone who has posted, by name, for resolving `@name`. */
+export const people = pgTable(
+  'a2slack_people',
+  {
+    id: text().primaryKey(),
+    name: text().notNull(),
+    /** The first message they posted. */
+    logIndex: logIndex(),
+  },
+  (table) => [index('a2slack_people_name').on(table.name)],
+)
+
+/** Who is in a thread: whoever posted in it or was named in it. */
+export const threadMembers = pgTable(
+  'a2slack_thread_members',
+  {
+    threadId: text().notNull(),
+    personId: text().notNull(),
+    /** When they joined it. */
+    logIndex: logIndex(),
+  },
+  (table) => [primaryKey({ columns: [table.threadId, table.personId] })],
+)
+
+// A2's own tables, so the same migrations create them: a2.ts is a copy of
+// experimental-a2's sql/postgres/drizzle-schema.ts.
+export * from './a2'