Merge branch 'main'

apps/server/src/database/repos/attachment/attachment.repo.ts

@@ -7,6 +7,7 @@ import {
   InsertableAttachment,
   UpdatableAttachment,
 } from '@docmost/db/types/entity.types';
+import { AttachmentType } from '../../../core/attachment/attachment.constants';
 
 @Injectable()
 export class AttachmentRepo {
@@ -23,6 +24,7 @@ export class AttachmentRepo {
     'creatorId',
     'pageId',
     'spaceId',
+    'aiChatId',
     'workspaceId',
     'createdAt',
     'updatedAt',
@@ -44,6 +46,21 @@ export class AttachmentRepo {
       .executeTakeFirst();
   }
 
+  async findByIdWithContent(
+    attachmentId: string,
+    opts?: {
+      trx?: KyselyTransaction;
+    },
+  ): Promise<Attachment> {
+    const db = dbOrTx(this.db, opts?.trx);
+
+    return db
+      .selectFrom('attachments')
+      .select([...this.baseFields, 'textContent'])
+      .where('id', '=', attachmentId)
+      .executeTakeFirst();
+  }
+
   async insertAttachment(
     insertableAttachment: InsertableAttachment,
     trx?: KyselyTransaction,
@@ -72,6 +89,21 @@ export class AttachmentRepo {
       .execute();
   }
 
+  async findByAiChatId(
+    aiChatId: string,
+    opts?: {
+      trx?: KyselyTransaction;
+    },
+  ): Promise<Attachment[]> {
+    const db = dbOrTx(this.db, opts?.trx);
+
+    return db
+      .selectFrom('attachments')
+      .select(this.baseFields)
+      .where('aiChatId', '=', aiChatId)
+      .execute();
+  }
+
   updateAttachmentsByPageId(
     updatableAttachment: UpdatableAttachment,
     pageIds: string[],
@@ -97,6 +129,25 @@ export class AttachmentRepo {
       .executeTakeFirst();
   }
 
+  async claimAttachmentsForChat(
+    attachmentIds: string[],
+    aiChatId: string,
+    creatorId: string,
+    workspaceId: string,
+  ): Promise<void> {
+    if (attachmentIds.length === 0) return;
+
+    await this.db
+      .updateTable('attachments')
+      .set({ aiChatId })
+      .where('id', 'in', attachmentIds)
+      .where('creatorId', '=', creatorId)
+      .where('workspaceId', '=', workspaceId)
+      .where('type', '=', AttachmentType.Chat)
+      .where('aiChatId', 'is', null)
+      .execute();
+  }
+
   async deleteAttachmentById(attachmentId: string): Promise<void> {
     await this.db
       .deleteFrom('attachments')

apps/server/src/database/repos/notification/notification.repo.ts

@@ -11,6 +11,7 @@ import { ExpressionBuilder } from 'kysely';
 import { DB } from '@docmost/db/types/db';
 import { jsonObjectFrom } from 'kysely/helpers/postgres';
 import { SpaceMemberRepo } from '@docmost/db/repos/space/space-member.repo';
+import { NotificationTab, NotificationType } from '../../../core/notification/notification.constants';
 
 @Injectable()
 export class NotificationRepo {
@@ -27,8 +28,12 @@ export class NotificationRepo {
       .executeTakeFirst();
   }
 
-  async findByUserId(userId: string, pagination: PaginationOptions) {
-    const query = this.db
+  async findByUserId(
+    userId: string,
+    pagination: PaginationOptions,
+    type: NotificationTab = 'all',
+  ) {
+    let query = this.db
       .selectFrom('notifications')
       .selectAll('notifications')
       .select((eb) => this.withActor(eb))
@@ -42,6 +47,12 @@ export class NotificationRepo {
         ]),
       );
 
+    if (type === 'direct') {
+      query = query.where('type', '!=', NotificationType.PAGE_UPDATED);
+    } else if (type === 'updates') {
+      query = query.where('type', '=', NotificationType.PAGE_UPDATED);
+    }
+
     return executeWithCursorPagination(query, {
       perPage: pagination.limit,
       cursor: pagination.cursor,
@@ -138,6 +149,29 @@ export class NotificationRepo {
       .execute();
   }
 
+  async getRecentlyNotifiedUserIds(
+    userIds: string[],
+    pageId: string,
+    type: string,
+    withinHours: number,
+  ): Promise<Set<string>> {
+    if (userIds.length === 0) return new Set();
+
+    const cutoff = new Date(Date.now() - withinHours * 60 * 60 * 1000);
+
+    const rows = await this.db
+      .selectFrom('notifications')
+      .select('userId')
+      .where('userId', 'in', userIds)
+      .where('pageId', '=', pageId)
+      .where('type', '=', type)
+      .where('createdAt', '>', cutoff)
+      .groupBy('userId')
+      .execute();
+
+    return new Set(rows.map((r) => r.userId));
+  }
+
   withActor(eb: ExpressionBuilder<DB, 'notifications'>) {
     return jsonObjectFrom(
       eb

apps/server/src/database/repos/session/user-session.repo.ts

@@ -0,0 +1,162 @@
+import {
+  InsertableUserSession,
+  UserSession,
+} from '@docmost/db/types/entity.types';
+import { KyselyDB, KyselyTransaction } from '@docmost/db/types/kysely.types';
+import { dbOrTx } from '@docmost/db/utils';
+import { Injectable } from '@nestjs/common';
+import { InjectKysely } from 'nestjs-kysely';
+import { sql } from 'kysely';
+
+@Injectable()
+export class UserSessionRepo {
+  constructor(@InjectKysely() private readonly db: KyselyDB) {}
+
+  async insertSession(
+    session: InsertableUserSession,
+    trx?: KyselyTransaction,
+  ): Promise<UserSession> {
+    const db = dbOrTx(this.db, trx);
+    return db
+      .insertInto('userSessions')
+      .values(session)
+      .returningAll()
+      .executeTakeFirstOrThrow();
+  }
+
+  async findActiveById(id: string): Promise<UserSession | undefined> {
+    return this.db
+      .selectFrom('userSessions')
+      .selectAll()
+      .where('id', '=', id)
+      .where('expiresAt', '>', new Date())
+      .where('revokedAt', 'is', null)
+      .executeTakeFirst();
+  }
+
+  async findActiveByUser(
+    userId: string,
+    workspaceId: string,
+  ): Promise<UserSession[]> {
+    return this.db
+      .selectFrom('userSessions')
+      .selectAll()
+      .where('userId', '=', userId)
+      .where('workspaceId', '=', workspaceId)
+      .where('expiresAt', '>', new Date())
+      .where('revokedAt', 'is', null)
+      .orderBy('lastActiveAt', 'desc')
+      .execute();
+  }
+
+  async updateLastActiveAt(id: string): Promise<void> {
+    await this.db
+      .updateTable('userSessions')
+      .set({ lastActiveAt: new Date() })
+      .where('id', '=', id)
+      .execute();
+  }
+
+  async revokeById(
+    id: string,
+    userId: string,
+    workspaceId: string,
+  ): Promise<void> {
+    await this.db
+      .updateTable('userSessions')
+      .set({ revokedAt: new Date() })
+      .where('id', '=', id)
+      .where('userId', '=', userId)
+      .where('workspaceId', '=', workspaceId)
+      .where('revokedAt', 'is', null)
+      .execute();
+  }
+
+  async revokeAllExceptCurrent(
+    currentSessionId: string,
+    userId: string,
+    workspaceId: string,
+  ): Promise<void> {
+    await this.db
+      .updateTable('userSessions')
+      .set({ revokedAt: new Date() })
+      .where('userId', '=', userId)
+      .where('workspaceId', '=', workspaceId)
+      .where('id', '!=', currentSessionId)
+      .where('revokedAt', 'is', null)
+      .execute();
+  }
+
+  async revokeByUserId(
+    userId: string,
+    workspaceId: string,
+    trx?: KyselyTransaction,
+  ): Promise<void> {
+    const db = dbOrTx(this.db, trx);
+    await db
+      .updateTable('userSessions')
+      .set({ revokedAt: new Date() })
+      .where('userId', '=', userId)
+      .where('workspaceId', '=', workspaceId)
+      .where('revokedAt', 'is', null)
+      .execute();
+  }
+
+  async deleteByUserId(
+    userId: string,
+    workspaceId: string,
+  ): Promise<void> {
+    await this.db
+      .deleteFrom('userSessions')
+      .where('userId', '=', userId)
+      .where('workspaceId', '=', workspaceId)
+      .execute();
+  }
+
+  async deleteAllExceptCurrent(
+    currentSessionId: string,
+    userId: string,
+    workspaceId: string,
+  ): Promise<void> {
+    await this.db
+      .deleteFrom('userSessions')
+      .where('userId', '=', userId)
+      .where('workspaceId', '=', workspaceId)
+      .where('id', '!=', currentSessionId)
+      .execute();
+  }
+
+  async deleteStale(retentionDays: number): Promise<void> {
+    const cutoff = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000);
+    await this.db
+      .deleteFrom('userSessions')
+      .where((eb) =>
+        eb.or([
+          eb('revokedAt', '<', cutoff),
+          eb('expiresAt', '<', cutoff),
+        ]),
+      )
+      .execute();
+  }
+
+  async trimExcessSessions(maxPerUser: number): Promise<void> {
+    const overflowed = await this.db
+      .selectFrom('userSessions')
+      .select(['userId', 'workspaceId'])
+      .groupBy(['userId', 'workspaceId'])
+      .having(sql`COUNT(*)`, '>', maxPerUser)
+      .execute();
+
+    for (const { userId, workspaceId } of overflowed) {
+      await sql`
+        DELETE FROM user_sessions
+        WHERE id IN (
+          SELECT id FROM user_sessions
+          WHERE user_id = ${userId} AND workspace_id = ${workspaceId}
+          ORDER BY last_active_at DESC
+          OFFSET ${maxPerUser}
+        )
+      `.execute(this.db);
+    }
+  }
+}

apps/server/src/database/repos/space/space.repo.ts

@@ -111,6 +111,28 @@ export class SpaceRepo {
       .executeTakeFirst();
   }
 
+  async updateCommentSettings(
+    spaceId: string,
+    workspaceId: string,
+    prefKey: string,
+    prefValue: string | boolean,
+    trx?: KyselyTransaction,
+  ) {
+    const db = dbOrTx(this.db, trx);
+    return db
+      .updateTable('spaces')
+      .set({
+        settings: sql`COALESCE(settings, '{}'::jsonb)
+          || jsonb_build_object('comments', COALESCE(settings->'comments', '{}'::jsonb)
+          || jsonb_build_object('${sql.raw(prefKey)}', ${sql.lit(prefValue)}))`,
+        updatedAt: new Date(),
+      })
+      .where('id', '=', spaceId)
+      .where('workspaceId', '=', workspaceId)
+      .returningAll()
+      .executeTakeFirst();
+  }
+
   async insertSpace(
     insertableSpace: InsertableSpace,
     trx?: KyselyTransaction,

apps/server/src/database/repos/user/user.repo.ts

@@ -13,6 +13,7 @@ import { PaginationOptions } from '../../pagination/pagination-options';
 import { executeWithCursorPagination } from '@docmost/db/pagination/cursor-pagination';
 import { ExpressionBuilder, sql } from 'kysely';
 import { jsonObjectFrom } from 'kysely/helpers/postgres';
+import { NotificationSettingKey } from '../../../core/notification/notification.constants';
 
 @Injectable()
 export class UserRepo {
@@ -191,6 +192,24 @@ export class UserRepo {
       .executeTakeFirst();
   }
 
+  async updateNotificationSetting(
+    userId: string,
+    settingKey: NotificationSettingKey,
+    settingValue: boolean,
+  ) {
+    return await this.db
+      .updateTable('users')
+      .set({
+        settings: sql`COALESCE(settings, '{}'::jsonb)
+                || jsonb_build_object('notifications', COALESCE(settings->'notifications', '{}'::jsonb)
+                || jsonb_build_object(${sql.lit(settingKey)}, ${sql.lit(settingValue)}))`,
+        updatedAt: new Date(),
+      })
+      .where('id', '=', userId)
+      .returning(this.baseFields)
+      .executeTakeFirst();
+  }
+
   withUserMfa(eb: ExpressionBuilder<DB, 'users'>) {
     return jsonObjectFrom(
       eb

apps/server/src/database/repos/watcher/watcher.repo.ts

@@ -20,18 +20,6 @@ export type WatcherType = (typeof WatcherType)[keyof typeof WatcherType];
 export class WatcherRepo {
   constructor(@InjectKysely() private readonly db: KyselyDB) {}
 
-  async findByUserAndPage(
-    userId: string,
-    pageId: string,
-  ): Promise<Watcher | undefined> {
-    return this.db
-      .selectFrom('watchers')
-      .selectAll()
-      .where('userId', '=', userId)
-      .where('pageId', '=', pageId)
-      .executeTakeFirst();
-  }
-
   async findPageWatchers(pageId: string, pagination: PaginationOptions) {
     const query = this.db
       .selectFrom('watchers')
@@ -66,6 +54,53 @@ export class WatcherRepo {
     return watchers.map((w) => w.userId);
   }
 
+  /**
+   * Recipients for a `page.updated` notification, combining:
+   *   - Active page watchers on this page, AND
+   *   - Active space watchers on this space, EXCLUDING any user who has a
+   *     muted page watcher row for this page (per-page mute always wins).
+   *
+   * Deduplicated at the SQL level — a user watching both the page and the
+   * containing space appears once.
+   */
+  async getPageUpdateRecipientIds(
+    pageId: string,
+    spaceId: string,
+    trx?: KyselyTransaction,
+  ): Promise<string[]> {
+    const db = dbOrTx(this.db, trx);
+
+    const pageWatchers = db
+      .selectFrom('watchers')
+      .select('userId')
+      .where('pageId', '=', pageId)
+      .where('type', '=', WatcherType.PAGE)
+      .where('mutedAt', 'is', null);
+
+    const spaceWatchers = db
+      .selectFrom('watchers as sw')
+      .select('sw.userId')
+      .where('sw.spaceId', '=', spaceId)
+      .where('sw.pageId', 'is', null)
+      .where('sw.type', '=', WatcherType.SPACE)
+      .where((eb) =>
+        eb.not(
+          eb.exists(
+            eb
+              .selectFrom('watchers as pw')
+              .select('pw.id')
+              .whereRef('pw.userId', '=', 'sw.userId')
+              .where('pw.pageId', '=', pageId)
+              .where('pw.type', '=', WatcherType.PAGE)
+              .where('pw.mutedAt', 'is not', null),
+          ),
+        ),
+      );
+
+    const rows = await pageWatchers.union(spaceWatchers).execute();
+    return [...new Set(rows.map((r) => r.userId))];
+  }
+
   async insert(
     watcher: InsertableWatcher,
     trx?: KyselyTransaction,
@@ -110,20 +145,81 @@ export class WatcherRepo {
       .executeTakeFirst();
   }
 
+  async upsertSpace(
+    watcher: InsertableWatcher,
+    trx?: KyselyTransaction,
+  ): Promise<Watcher | undefined> {
+    const db = dbOrTx(this.db, trx);
+    return db
+      .insertInto('watchers')
+      .values(watcher)
+      .onConflict((oc) =>
+        oc
+          .columns(['userId', 'spaceId'])
+          .where('pageId', 'is', null)
+          .doNothing(),
+      )
+      .returningAll()
+      .executeTakeFirst();
+  }
+
   async mute(
     userId: string,
     pageId: string,
+    spaceId: string,
+    workspaceId: string,
+    trx?: KyselyTransaction,
+  ): Promise<void> {
+    const db = dbOrTx(this.db, trx);
+    const mutedAt = new Date();
+    await db
+      .insertInto('watchers')
+      .values({
+        userId,
+        pageId,
+        spaceId,
+        workspaceId,
+        type: WatcherType.PAGE,
+        addedById: userId,
+        mutedAt,
+      })
+      .onConflict((oc) =>
+        oc
+          .columns(['userId', 'pageId'])
+          .where('pageId', 'is not', null)
+          .doUpdateSet({ mutedAt }),
+      )
+      .execute();
+  }
+
+  async deleteSpaceWatch(
+    userId: string,
+    spaceId: string,
     trx?: KyselyTransaction,
   ): Promise<void> {
     const db = dbOrTx(this.db, trx);
     await db
-      .updateTable('watchers')
-      .set({ mutedAt: new Date() })
+      .deleteFrom('watchers')
       .where('userId', '=', userId)
-      .where('pageId', '=', pageId)
+      .where('spaceId', '=', spaceId)
+      .where('pageId', 'is', null)
+      .where('type', '=', WatcherType.SPACE)
       .execute();
   }
 
+  async isWatchingSpace(userId: string, spaceId: string): Promise<boolean> {
+    const watcher = await this.db
+      .selectFrom('watchers')
+      .select('id')
+      .where('userId', '=', userId)
+      .where('spaceId', '=', spaceId)
+      .where('pageId', 'is', null)
+      .where('type', '=', WatcherType.SPACE)
+      .executeTakeFirst();
+
+    return !!watcher;
+  }
+
   async isWatching(userId: string, pageId: string): Promise<boolean> {
     const watcher = await this.db
       .selectFrom('watchers')
@@ -164,14 +260,14 @@ export class WatcherRepo {
       .where('spaceId', '=', spaceId)
       .where('userId', 'is not', null)
       .union(
-        this.db
+        db
           .selectFrom('spaceMembers')
           .innerJoin('groupUsers', 'groupUsers.groupId', 'spaceMembers.groupId')
           .select('groupUsers.userId')
           .where('spaceMembers.spaceId', '=', spaceId),
       );
 
-    await this.db
+    await db
       .deleteFrom('watchers')
       .where('userId', 'in', userIds)
       .where('spaceId', '=', spaceId)