feat: favorites (#2103)

* feat: favorites and templates(ee)

* rename migrations

* fix sidebar

* cleanup tabs

* fix

* turn off templates

* cleanup

* uuid validation

apps/server/src/database/database.module.ts

@@ -22,6 +22,8 @@ import { BacklinkRepo } from '@docmost/db/repos/backlink/backlink.repo';
 import { ShareRepo } from '@docmost/db/repos/share/share.repo';
 import { NotificationRepo } from '@docmost/db/repos/notification/notification.repo';
 import { WatcherRepo } from '@docmost/db/repos/watcher/watcher.repo';
+import { FavoriteRepo } from '@docmost/db/repos/favorite/favorite.repo';
+import { TemplateRepo } from '@docmost/db/repos/template/template.repo';
 import { PageListener } from '@docmost/db/listeners/page.listener';
 import { PostgresJSDialect } from 'kysely-postgres-js';
 import * as postgres from 'postgres';
@@ -75,6 +77,7 @@ import { normalizePostgresUrl } from '../common/helpers';
     PagePermissionRepo,
     PageHistoryRepo,
     CommentRepo,
+    FavoriteRepo,
     AttachmentRepo,
     UserTokenRepo,
     UserSessionRepo,
@@ -82,6 +85,7 @@ import { normalizePostgresUrl } from '../common/helpers';
     ShareRepo,
     NotificationRepo,
     WatcherRepo,
+    TemplateRepo,
     PageListener,
   ],
   exports: [
@@ -95,6 +99,7 @@ import { normalizePostgresUrl } from '../common/helpers';
     PagePermissionRepo,
     PageHistoryRepo,
     CommentRepo,
+    FavoriteRepo,
     AttachmentRepo,
     UserTokenRepo,
     UserSessionRepo,
@@ -102,6 +107,7 @@ import { normalizePostgresUrl } from '../common/helpers';
     ShareRepo,
     NotificationRepo,
     WatcherRepo,
+    TemplateRepo,
   ],
 })
 export class DatabaseModule implements OnApplicationBootstrap {

apps/server/src/database/migrations/20260412T135891-templates.ts

@@ -0,0 +1,76 @@
+import { Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable('templates')
+    .addColumn('id', 'uuid', (col) =>
+      col.primaryKey().defaultTo(sql`gen_uuid_v7()`),
+    )
+    .addColumn('title', 'varchar')
+    .addColumn('description', 'text')
+    .addColumn('content', 'jsonb')
+    .addColumn('ydoc', 'bytea')
+    .addColumn('icon', 'varchar')
+    .addColumn('space_id', 'uuid', (col) =>
+      col.references('spaces.id').onDelete('cascade'),
+    )
+    .addColumn('workspace_id', 'uuid', (col) =>
+      col.notNull().references('workspaces.id').onDelete('cascade'),
+    )
+    .addColumn('creator_id', 'uuid', (col) =>
+      col.references('users.id').onDelete('set null'),
+    )
+    .addColumn('last_updated_by_id', 'uuid', (col) =>
+      col.references('users.id').onDelete('set null'),
+    )
+    .addColumn('collaborator_ids', sql`uuid[]`)
+    .addColumn('text_content', 'text', (col) => col)
+    .addColumn('tsv', sql`tsvector`, (col) => col)
+    .addColumn('created_at', 'timestamptz', (col) =>
+      col.notNull().defaultTo(sql`now()`),
+    )
+    .addColumn('updated_at', 'timestamptz', (col) =>
+      col.notNull().defaultTo(sql`now()`),
+    )
+    .addColumn('deleted_at', 'timestamptz')
+    .execute();
+
+  await db.schema
+    .createIndex('idx_templates_workspace_id')
+    .on('templates')
+    .columns(['workspace_id'])
+    .execute();
+
+  await db.schema
+    .createIndex('idx_templates_space_id')
+    .on('templates')
+    .columns(['space_id'])
+    .execute();
+
+  await db.schema
+    .createIndex('templates_tsv_idx')
+    .on('templates')
+    .using('GIN')
+    .column('tsv')
+    .execute();
+
+  await sql`
+    CREATE OR REPLACE FUNCTION templates_tsvector_trigger() RETURNS trigger AS $$
+    begin
+        new.tsv :=
+                  setweight(to_tsvector('english', f_unaccent(coalesce(new.title, ''))), 'A') ||
+                  setweight(to_tsvector('english', f_unaccent(substring(coalesce(new.text_content, ''), 1, 1000000))), 'B');
+        return new;
+    end;
+    $$ LANGUAGE plpgsql;
+  `.execute(db);
+
+  await sql`CREATE OR REPLACE TRIGGER templates_tsvector_update BEFORE INSERT OR UPDATE
+                ON templates FOR EACH ROW EXECUTE FUNCTION templates_tsvector_trigger();`.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`DROP TRIGGER IF EXISTS templates_tsvector_update ON templates`.execute(db);
+  await sql`DROP FUNCTION IF EXISTS templates_tsvector_trigger`.execute(db);
+  await db.schema.dropTable('templates').execute();
+}

apps/server/src/database/migrations/20260412T162318-favorites.ts

@@ -0,0 +1,63 @@
+import { type Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable('favorites')
+    .addColumn('id', 'uuid', (col) =>
+      col.primaryKey().defaultTo(sql`gen_uuid_v7()`),
+    )
+    .addColumn('user_id', 'uuid', (col) =>
+      col.references('users.id').onDelete('cascade').notNull(),
+    )
+    .addColumn('page_id', 'uuid', (col) =>
+      col.references('pages.id').onDelete('cascade'),
+    )
+    .addColumn('space_id', 'uuid', (col) =>
+      col.references('spaces.id').onDelete('cascade'),
+    )
+    .addColumn('template_id', 'uuid', (col) =>
+      col.references('templates.id').onDelete('cascade'),
+    )
+    .addColumn('type', 'varchar', (col) => col.notNull())
+    .addColumn('workspace_id', 'uuid', (col) =>
+      col.references('workspaces.id').onDelete('cascade').notNull(),
+    )
+    .addColumn('created_at', 'timestamptz', (col) =>
+      col.defaultTo(sql`now()`).notNull(),
+    )
+    .execute();
+
+  await db.schema
+    .createIndex('idx_favorites_user_page')
+    .on('favorites')
+    .columns(['user_id', 'page_id'])
+    .unique()
+    .where('page_id', 'is not', null)
+    .execute();
+
+  await db.schema
+    .createIndex('idx_favorites_user_space')
+    .on('favorites')
+    .columns(['user_id', 'space_id'])
+    .unique()
+    .where('space_id', 'is not', null)
+    .execute();
+
+  await db.schema
+    .createIndex('idx_favorites_user_template')
+    .on('favorites')
+    .columns(['user_id', 'template_id'])
+    .unique()
+    .where('template_id', 'is not', null)
+    .execute();
+
+  await db.schema
+    .createIndex('idx_favorites_user_workspace_type')
+    .on('favorites')
+    .columns(['user_id', 'workspace_id', 'type'])
+    .execute();
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await db.schema.dropTable('favorites').execute();
+}

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

@@ -0,0 +1,216 @@
+import { Injectable } from '@nestjs/common';
+import { InjectKysely } from 'nestjs-kysely';
+import { KyselyDB, KyselyTransaction } from '@docmost/db/types/kysely.types';
+import { InsertableFavorite, Favorite } from '@docmost/db/types/entity.types';
+import { PaginationOptions } from '@docmost/db/pagination/pagination-options';
+import { executeWithCursorPagination } from '@docmost/db/pagination/cursor-pagination';
+import { jsonObjectFrom } from 'kysely/helpers/postgres';
+import { ExpressionBuilder, sql } from 'kysely';
+import { DB } from '@docmost/db/types/db';
+import { dbOrTx } from '@docmost/db/utils';
+
+export const FavoriteType = {
+  PAGE: 'page',
+  SPACE: 'space',
+  TEMPLATE: 'template',
+} as const;
+
+export type FavoriteType = (typeof FavoriteType)[keyof typeof FavoriteType];
+
+@Injectable()
+export class FavoriteRepo {
+  constructor(@InjectKysely() private readonly db: KyselyDB) {}
+
+  async insert(favorite: InsertableFavorite): Promise<Favorite | undefined> {
+    try {
+      return await this.db
+        .insertInto('favorites')
+        .values(favorite)
+        .returningAll()
+        .executeTakeFirst();
+    } catch (err: any) {
+      if (err?.code === '23505') return undefined;
+      throw err;
+    }
+  }
+
+  async deleteByUserAndPage(userId: string, pageId: string): Promise<void> {
+    await this.db
+      .deleteFrom('favorites')
+      .where('userId', '=', userId)
+      .where('pageId', '=', pageId)
+      .execute();
+  }
+
+  async deleteByUserAndSpace(userId: string, spaceId: string): Promise<void> {
+    await this.db
+      .deleteFrom('favorites')
+      .where('userId', '=', userId)
+      .where('spaceId', '=', spaceId)
+      .where('type', '=', FavoriteType.SPACE)
+      .execute();
+  }
+
+  async deleteByUserAndTemplate(
+    userId: string,
+    templateId: string,
+  ): Promise<void> {
+    await this.db
+      .deleteFrom('favorites')
+      .where('userId', '=', userId)
+      .where('templateId', '=', templateId)
+      .execute();
+  }
+
+  async findUserFavorites(
+    userId: string,
+    workspaceId: string,
+    pagination: PaginationOptions,
+    type?: FavoriteType,
+  ) {
+    let query = this.db
+      .selectFrom('favorites')
+      .selectAll('favorites')
+      .where('favorites.userId', '=', userId)
+      .where('favorites.workspaceId', '=', workspaceId);
+
+    if (type) {
+      query = query.where('favorites.type', '=', type);
+    }
+
+    if (type === FavoriteType.PAGE || !type) {
+      query = query.select((eb) => this.withPage(eb));
+    }
+
+    if (type === FavoriteType.PAGE) {
+      query = query.select((eb) => this.withPageSpace(eb));
+    } else if (type === FavoriteType.SPACE) {
+      query = query.select((eb) => this.withSpace(eb));
+    } else {
+      query = query.select((eb) => this.withSpaceResolved(eb));
+    }
+
+    if (type === FavoriteType.TEMPLATE || !type) {
+      query = query.select((eb) => this.withTemplate(eb));
+    }
+
+    return executeWithCursorPagination(query, {
+      perPage: pagination.limit,
+      cursor: pagination.cursor,
+      beforeCursor: pagination.beforeCursor,
+      fields: [{ expression: 'favorites.id', direction: 'desc' }],
+      parseCursor: (cursor) => ({
+        id: cursor.id,
+      }),
+    });
+  }
+
+  async deleteByUsersWithoutSpaceAccess(
+    userIds: string[],
+    spaceId: string,
+    opts?: { trx?: KyselyTransaction },
+  ): Promise<void> {
+    if (userIds.length === 0) return;
+
+    const { trx } = opts;
+    const db = dbOrTx(this.db, trx);
+
+    const usersWithAccess = db
+      .selectFrom('spaceMembers')
+      .select('userId')
+      .where('spaceId', '=', spaceId)
+      .where('userId', 'is not', null)
+      .union(
+        db
+          .selectFrom('spaceMembers')
+          .innerJoin('groupUsers', 'groupUsers.groupId', 'spaceMembers.groupId')
+          .select('groupUsers.userId')
+          .where('spaceMembers.spaceId', '=', spaceId),
+      );
+
+    await db
+      .deleteFrom('favorites')
+      .where('userId', 'in', userIds)
+      .where('spaceId', '=', spaceId)
+      .where('userId', 'not in', usersWithAccess)
+      .execute();
+  }
+
+  async deleteByUserAndWorkspace(
+    userId: string,
+    workspaceId: string,
+    opts?: { trx?: KyselyTransaction },
+  ): Promise<void> {
+    const { trx } = opts;
+    const db = dbOrTx(this.db, trx);
+
+    await db
+      .deleteFrom('favorites')
+      .where('userId', '=', userId)
+      .where('workspaceId', '=', workspaceId)
+      .execute();
+  }
+
+  private withPage(eb: ExpressionBuilder<DB, 'favorites'>) {
+    return jsonObjectFrom(
+      eb
+        .selectFrom('pages')
+        .select([
+          'pages.id',
+          'pages.slugId',
+          'pages.title',
+          'pages.icon',
+          'pages.spaceId',
+        ])
+        .whereRef('pages.id', '=', 'favorites.pageId'),
+    ).as('page');
+  }
+
+  private withSpace(eb: ExpressionBuilder<DB, 'favorites'>) {
+    return jsonObjectFrom(
+      eb
+        .selectFrom('spaces')
+        .select(['spaces.id', 'spaces.name', 'spaces.slug', 'spaces.logo'])
+        .whereRef('spaces.id', '=', 'favorites.spaceId'),
+    ).as('space');
+  }
+
+  private withPageSpace(eb: ExpressionBuilder<DB, 'favorites'>) {
+    return jsonObjectFrom(
+      eb
+        .selectFrom('spaces')
+        .innerJoin('pages', 'pages.spaceId', 'spaces.id')
+        .select(['spaces.id', 'spaces.name', 'spaces.slug', 'spaces.logo'])
+        .whereRef('pages.id', '=', 'favorites.pageId'),
+    ).as('space');
+  }
+
+  private withSpaceResolved(eb: ExpressionBuilder<DB, 'favorites'>) {
+    return jsonObjectFrom(
+      eb
+        .selectFrom('spaces')
+        .select(['spaces.id', 'spaces.name', 'spaces.slug', 'spaces.logo'])
+        .where(({ or, ref }) =>
+          or([
+            sql<boolean>`${ref('spaces.id')} = ${ref('favorites.spaceId')}`,
+            sql<boolean>`${ref('spaces.id')} = (SELECT pages.space_id FROM pages WHERE pages.id = ${ref('favorites.pageId')})`,
+          ]),
+        ),
+    ).as('space');
+  }
+
+  private withTemplate(eb: ExpressionBuilder<DB, 'favorites'>) {
+    return jsonObjectFrom(
+      eb
+        .selectFrom('templates')
+        .select([
+          'templates.id',
+          'templates.title',
+          'templates.description',
+          'templates.icon',
+          'templates.spaceId',
+        ])
+        .whereRef('templates.id', '=', 'favorites.templateId'),
+    ).as('template');
+  }
+}

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

@@ -324,6 +324,35 @@ export class PageRepo {
     });
   }
 
+  async getCreatedByPages(creatorId: string, requestingUserId: string, pagination: PaginationOptions, spaceId?: string) {
+    let query = this.db
+      .selectFrom('pages')
+      .select(this.baseFields)
+      .select((eb) => this.withSpace(eb))
+      .where('creatorId', '=', creatorId)
+      .where('deletedAt', 'is', null);
+
+    if (spaceId) {
+      query = query.where('spaceId', '=', spaceId);
+    } else {
+      query = query.where('spaceId', 'in', this.spaceMemberRepo.getUserSpaceIdsQuery(requestingUserId));
+    }
+
+    return executeWithCursorPagination(query, {
+      perPage: pagination.limit,
+      cursor: pagination.cursor,
+      beforeCursor: pagination.beforeCursor,
+      fields: [
+        { expression: 'updatedAt', direction: 'desc' },
+        { expression: 'id', direction: 'desc' },
+      ],
+      parseCursor: (cursor) => ({
+        updatedAt: new Date(cursor.updatedAt),
+        id: cursor.id,
+      }),
+    });
+  }
+
   async getDeletedPagesInSpace(spaceId: string, pagination: PaginationOptions) {
     const query = this.db
       .selectFrom('pages')

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

@@ -290,6 +290,32 @@ export class SpaceMemberRepo {
     return membership.map((space) => space.id);
   }
 
+  async getUserRolesForSpaces(
+    userId: string,
+    spaceIds: string[],
+  ): Promise<{ spaceId: string; role: string }[]> {
+    if (spaceIds.length === 0) return [];
+
+    return this.db
+      .selectFrom('spaceMembers')
+      .select(['spaceId', 'role'])
+      .where('userId', '=', userId)
+      .where('spaceId', 'in', spaceIds)
+      .unionAll(
+        this.db
+          .selectFrom('spaceMembers')
+          .innerJoin(
+            'groupUsers',
+            'groupUsers.groupId',
+            'spaceMembers.groupId',
+          )
+          .select(['spaceMembers.spaceId', 'spaceMembers.role'])
+          .where('groupUsers.userId', '=', userId)
+          .where('spaceMembers.spaceId', 'in', spaceIds),
+      )
+      .execute();
+  }
+
   async getUserSpaces(userId: string, pagination: PaginationOptions) {
     let query = this.db
       .selectFrom('spaces')

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

@@ -0,0 +1,160 @@
+import { Injectable } from '@nestjs/common';
+import { InjectKysely } from 'nestjs-kysely';
+import { KyselyDB, KyselyTransaction } from '@docmost/db/types/kysely.types';
+import { dbOrTx } from '@docmost/db/utils';
+import {
+  InsertableTemplate,
+  Page,
+  Template,
+  UpdatableTemplate,
+} from '@docmost/db/types/entity.types';
+import { PaginationOptions } from '../../pagination/pagination-options';
+import { executeWithCursorPagination } from '@docmost/db/pagination/cursor-pagination';
+import { ExpressionBuilder, sql } from 'kysely';
+import { DB } from '@docmost/db/types/db';
+import { jsonObjectFrom } from 'kysely/helpers/postgres';
+
+@Injectable()
+export class TemplateRepo {
+  private baseFields: Array<keyof Template> = [
+    'id',
+    'title',
+    'description',
+    'icon',
+    'spaceId',
+    'workspaceId',
+    'creatorId',
+    'lastUpdatedById',
+    'createdAt',
+    'updatedAt',
+  ];
+
+  constructor(@InjectKysely() private readonly db: KyselyDB) {}
+
+  async findById(
+    templateId: string,
+    workspaceId: string,
+    opts?: { includeContent?: boolean; trx?: KyselyTransaction },
+  ): Promise<Template> {
+    const db = dbOrTx(this.db, opts?.trx);
+
+    const query = db
+      .selectFrom('templates')
+      .select(this.baseFields)
+      .$if(opts?.includeContent ?? false, (qb) => qb.select('content'))
+      .select((eb) => [this.withCreator(eb)])
+      .where('id', '=', templateId)
+      .where('workspaceId', '=', workspaceId);
+
+    return query.executeTakeFirst() as Promise<Template>;
+  }
+
+  async findTemplates(
+    workspaceId: string,
+    accessibleSpaceIds: string[],
+    pagination: PaginationOptions,
+    opts?: { spaceId?: string },
+  ) {
+    let query = this.db
+      .selectFrom('templates')
+      .select(this.baseFields)
+      .select((eb) => [this.withCreator(eb)])
+      .where('workspaceId', '=', workspaceId);
+
+    if (opts?.spaceId) {
+      if (!accessibleSpaceIds.includes(opts.spaceId)) {
+        query = query.where('spaceId', 'is', null);
+      } else {
+        query = query.where((eb) =>
+          eb.or([eb('spaceId', '=', opts.spaceId), eb('spaceId', 'is', null)]),
+        );
+      }
+    } else {
+      query = query.where((eb) =>
+        eb.or([
+          eb('spaceId', 'is', null),
+          ...(accessibleSpaceIds.length > 0
+            ? [eb('spaceId', 'in', accessibleSpaceIds)]
+            : []),
+        ]),
+      );
+    }
+
+    if (pagination.query) {
+      const searchTerm = `%${pagination.query}%`;
+      query = query.where((eb) =>
+        eb.or([
+          eb(sql`f_unaccent(title)`, 'ilike', sql`f_unaccent(${searchTerm})`),
+          eb(
+            sql`f_unaccent(description)`,
+            'ilike',
+            sql`f_unaccent(${searchTerm})`,
+          ),
+        ]),
+      );
+    }
+
+    return executeWithCursorPagination(query, {
+      perPage: pagination.limit,
+      cursor: pagination.cursor,
+      beforeCursor: pagination.beforeCursor,
+      fields: [
+        { expression: 'title', direction: 'asc' },
+        { expression: 'id', direction: 'asc' },
+      ],
+      parseCursor: (cursor) => ({
+        title: cursor.title,
+        id: cursor.id,
+      }),
+    });
+  }
+
+  async insertTemplate(
+    insertableTemplate: InsertableTemplate,
+    trx?: KyselyTransaction,
+  ): Promise<{ id: string }> {
+    const db = dbOrTx(this.db, trx);
+    return db
+      .insertInto('templates')
+      .values(insertableTemplate)
+      .returning('id')
+      .executeTakeFirst();
+  }
+
+  async updateTemplate(
+    updatableTemplate: UpdatableTemplate,
+    templateId: string,
+    workspaceId: string,
+    trx?: KyselyTransaction,
+  ): Promise<void> {
+    const db = dbOrTx(this.db, trx);
+    await db
+      .updateTable('templates')
+      .set({ ...updatableTemplate, updatedAt: new Date() })
+      .where('id', '=', templateId)
+      .where('workspaceId', '=', workspaceId)
+      .execute();
+  }
+
+  async deleteTemplate(
+    templateId: string,
+    workspaceId: string,
+    trx?: KyselyTransaction,
+  ): Promise<void> {
+    const db = dbOrTx(this.db, trx);
+    await db
+      .deleteFrom('templates')
+      .where('id', '=', templateId)
+      .where('workspaceId', '=', workspaceId)
+      .execute();
+  }
+
+  withCreator(eb: ExpressionBuilder<DB, 'templates'>) {
+    return jsonObjectFrom(
+      eb
+        .selectFrom('users')
+        .select(['users.id', 'users.name', 'users.avatarUrl'])
+        .whereRef('users.id', '=', 'templates.creatorId'),
+    ).as('creator');
+  }
+}

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

@@ -230,4 +230,24 @@ export class WorkspaceRepo {
       .executeTakeFirst();
   }
 
+  async updateTemplateSettings(
+    workspaceId: string,
+    prefKey: string,
+    prefValue: string | boolean,
+    trx?: KyselyTransaction,
+  ) {
+    const db = dbOrTx(this.db, trx);
+    return db
+      .updateTable('workspaces')
+      .set({
+        settings: sql`COALESCE(settings, '{}'::jsonb)
+                || jsonb_build_object('templates', COALESCE(settings->'templates', '{}'::jsonb)
+                || jsonb_build_object('${sql.raw(prefKey)}', ${sql.lit(prefValue)}))`,
+        updatedAt: new Date(),
+      })
+      .where('id', '=', workspaceId)
+      .returning(this.baseFields)
+      .executeTakeFirst();
+  }
+
 }

apps/server/src/database/types/db.d.ts

@@ -175,6 +175,17 @@ export interface Comments {
   workspaceId: string;
 }
 
+export interface Favorites {
+  id: Generated<string>;
+  userId: string;
+  pageId: string | null;
+  spaceId: string | null;
+  templateId: string | null;
+  type: string;
+  workspaceId: string;
+  createdAt: Generated<Timestamp>;
+}
+
 export interface FileTasks {
   createdAt: Generated<Timestamp>;
   creatorId: string | null;
@@ -430,6 +441,25 @@ export interface PagePermissions {
   updatedAt: Generated<Timestamp>;
 }
 
+export interface Templates {
+  id: Generated<string>;
+  title: string | null;
+  description: string | null;
+  content: Json | null;
+  ydoc: Buffer | null;
+  icon: string | null;
+  spaceId: string | null;
+  workspaceId: string;
+  creatorId: string | null;
+  lastUpdatedById: string | null;
+  collaboratorIds: string[] | null;
+  textContent: string | null;
+  tsv: string | null;
+  createdAt: Generated<Timestamp>;
+  updatedAt: Generated<Timestamp>;
+  deletedAt: Timestamp | null;
+}
+
 export interface AiChats {
   id: Generated<string>;
   workspaceId: string;
@@ -481,6 +511,7 @@ export interface DB {
   backlinks: Backlinks;
   billing: Billing;
   comments: Comments;
+  favorites: Favorites;
   fileTasks: FileTasks;
   groups: Groups;
   groupUsers: GroupUsers;
@@ -492,6 +523,7 @@ export interface DB {
   shares: Shares;
   spaceMembers: SpaceMembers;
   spaces: Spaces;
+  templates: Templates;
   userMfa: UserMfa;
   users: Users;
   userSessions: UserSessions;

apps/server/src/database/types/entity.types.ts

@@ -22,12 +22,14 @@ import {
   AuthProviders,
   AuthAccounts,
   Shares,
+  Favorites,
   FileTasks,
   UserMfa as _UserMFA,
   UserSessions,
   ApiKeys,
   Watchers,
   Audit as _Audit,
+  Templates,
 } from './db';
 import { PageEmbeddings } from '@docmost/db/types/embeddings.types';
 
@@ -135,6 +137,11 @@ export type Share = Selectable<Shares>;
 export type InsertableShare = Insertable<Shares>;
 export type UpdatableShare = Updateable<Omit<Shares, 'id'>>;
 
+// Favorite
+export type Favorite = Selectable<Favorites>;
+export type InsertableFavorite = Insertable<Favorites>;
+export type UpdatableFavorite = Updateable<Omit<Favorites, 'id'>>;
+
 // File Task
 export type FileTask = Selectable<FileTasks>;
 export type InsertableFileTask = Insertable<FileTasks>;
@@ -184,3 +191,8 @@ export type UpdatableUserSession = Updateable<Omit<UserSessions, 'id'>>;
 export type Audit = Selectable<_Audit>;
 export type InsertableAudit = Insertable<_Audit>;
 export type UpdatableAudit = Updateable<Omit<_Audit, 'id'>>;
+
+// Template
+export type Template = Selectable<Templates>;
+export type InsertableTemplate = Insertable<Templates>;
+export type UpdatableTemplate = Updateable<Omit<Templates, 'id'>>;