@lobehub/chat 1.74.2 → 1.74.3

package/src/database/migrations/meta/_journal.json

@@ -126,6 +126,13 @@
       "when": 1742269437903,
       "tag": "0017_add_user_id_to_tables",
       "breakpoints": true
+    },
+    {
+      "idx": 18,
+      "version": "7",
+      "when": 1742616026643,
+      "tag": "0018_add_client_id_for_entities",
+      "breakpoints": true
     }
   ],
   "version": "6"

package/src/database/models/drizzleMigration.ts

@@ -0,0 +1,23 @@
+import { LobeChatDatabase } from '@/database/type';
+import { MigrationTableItem } from '@/types/clientDB';
+
+export class DrizzleMigrationModel {
+  private db: LobeChatDatabase;
+
+  constructor(db: LobeChatDatabase) {
+    this.db = db;
+  }
+
+  getMigrationList = async () => {
+    const res = await this.db.execute(
+      'SELECT * FROM "drizzle"."__drizzle_migrations" ORDER BY "created_at" DESC;',
+    );
+
+    return res.rows as unknown as MigrationTableItem[];
+  };
+  getLatestMigrationHash = async () => {
+    const res = await this.getMigrationList();
+
+    return res[0].hash;
+  };
+}

package/src/database/schemas/agent.ts

@@ -1,5 +1,13 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix  */
-import { boolean, jsonb, pgTable, primaryKey, text, varchar } from 'drizzle-orm/pg-core';
+import {
+  boolean,
+  jsonb,
+  pgTable,
+  primaryKey,
+  text,
+  uniqueIndex,
+  varchar,
+} from 'drizzle-orm/pg-core';
 import { createInsertSchema } from 'drizzle-zod';
 
 import { idGenerator, randomSlug } from '@/database/utils/idGenerator';
@@ -13,36 +21,45 @@ import { users } from './user';
 // agent is a model that represents the assistant that is created by the user
 // agent can have its own knowledge base and files
 
-export const agents = pgTable('agents', {
-  id: text('id')
-    .primaryKey()
-    .$defaultFn(() => idGenerator('agents'))
-    .notNull(),
-  slug: varchar('slug', { length: 100 })
-    .$defaultFn(() => randomSlug(4))
-    .unique(),
-  title: text('title'),
-  description: text('description'),
-  tags: jsonb('tags').$type<string[]>().default([]),
-  avatar: text('avatar'),
-  backgroundColor: text('background_color'),
-
-  plugins: jsonb('plugins').$type<string[]>().default([]),
-  userId: text('user_id')
-    .references(() => users.id, { onDelete: 'cascade' })
-    .notNull(),
-
-  chatConfig: jsonb('chat_config').$type<LobeAgentChatConfig>(),
-
-  fewShots: jsonb('few_shots'),
-  model: text('model'),
-  params: jsonb('params').default({}),
-  provider: text('provider'),
-  systemRole: text('system_role'),
-  tts: jsonb('tts').$type<LobeAgentTTSConfig>(),
-
-  ...timestamps,
-});
+export const agents = pgTable(
+  'agents',
+  {
+    id: text('id')
+      .primaryKey()
+      .$defaultFn(() => idGenerator('agents'))
+      .notNull(),
+    slug: varchar('slug', { length: 100 })
+      .$defaultFn(() => randomSlug(4))
+      .unique(),
+    title: text('title'),
+    description: text('description'),
+    tags: jsonb('tags').$type<string[]>().default([]),
+    avatar: text('avatar'),
+    backgroundColor: text('background_color'),
+
+    plugins: jsonb('plugins').$type<string[]>().default([]),
+
+    clientId: text('client_id'),
+
+    userId: text('user_id')
+      .references(() => users.id, { onDelete: 'cascade' })
+      .notNull(),
+
+    chatConfig: jsonb('chat_config').$type<LobeAgentChatConfig>(),
+
+    fewShots: jsonb('few_shots'),
+    model: text('model'),
+    params: jsonb('params').default({}),
+    provider: text('provider'),
+    systemRole: text('system_role'),
+    tts: jsonb('tts').$type<LobeAgentTTSConfig>(),
+
+    ...timestamps,
+  },
+  (t) => ({
+    clientIdUnique: uniqueIndex('client_id_user_id_unique').on(t.clientId, t.userId),
+  }),
+);
 
 export const insertAgentSchema = createInsertSchema(agents);
 

package/src/database/schemas/file.ts

@@ -7,6 +7,7 @@ import {
   pgTable,
   primaryKey,
   text,
+  uniqueIndex,
   uuid,
   varchar,
 } from 'drizzle-orm/pg-core';
@@ -52,6 +53,7 @@ export const files = pgTable(
     size: integer('size').notNull(),
     url: text('url').notNull(),
 
+    clientId: text('client_id'),
     metadata: jsonb('metadata'),
     chunkTaskId: uuid('chunk_task_id').references(() => asyncTasks.id, { onDelete: 'set null' }),
     embeddingTaskId: uuid('embedding_task_id').references(() => asyncTasks.id, {
@@ -63,33 +65,47 @@ export const files = pgTable(
   (table) => {
     return {
       fileHashIdx: index('file_hash_idx').on(table.fileHash),
+      clientIdUnique: uniqueIndex('files_client_id_user_id_unique').on(
+        table.clientId,
+        table.userId,
+      ),
     };
   },
 );
 export type NewFile = typeof files.$inferInsert;
 export type FileItem = typeof files.$inferSelect;
 
-export const knowledgeBases = pgTable('knowledge_bases', {
-  id: text('id')
-    .$defaultFn(() => idGenerator('knowledgeBases'))
-    .primaryKey(),
+export const knowledgeBases = pgTable(
+  'knowledge_bases',
+  {
+    id: text('id')
+      .$defaultFn(() => idGenerator('knowledgeBases'))
+      .primaryKey(),
 
-  name: text('name').notNull(),
-  description: text('description'),
-  avatar: text('avatar'),
+    name: text('name').notNull(),
+    description: text('description'),
+    avatar: text('avatar'),
 
-  // different types of knowledge bases need to be distinguished
-  type: text('type'),
-  userId: text('user_id')
-    .references(() => users.id, { onDelete: 'cascade' })
-    .notNull(),
+    // different types of knowledge bases need to be distinguished
+    type: text('type'),
+    userId: text('user_id')
+      .references(() => users.id, { onDelete: 'cascade' })
+      .notNull(),
+    clientId: text('client_id'),
 
-  isPublic: boolean('is_public').default(false),
+    isPublic: boolean('is_public').default(false),
 
-  settings: jsonb('settings'),
+    settings: jsonb('settings'),
 
-  ...timestamps,
-});
+    ...timestamps,
+  },
+  (t) => ({
+    clientIdUnique: uniqueIndex('knowledge_bases_client_id_user_id_unique').on(
+      t.clientId,
+      t.userId,
+    ),
+  }),
+);
 
 export const insertKnowledgeBasesSchema = createInsertSchema(knowledgeBases);
 

package/src/database/schemas/message.ts

@@ -80,52 +80,79 @@ export const messages = pgTable(
 );
 
 // if the message container a plugin
-export const messagePlugins = pgTable('message_plugins', {
-  id: text('id')
-    .references(() => messages.id, { onDelete: 'cascade' })
-    .primaryKey(),
-
-  toolCallId: text('tool_call_id'),
-  type: text('type', {
-    enum: ['default', 'markdown', 'standalone', 'builtin'],
-  }).default('default'),
-
-  apiName: text('api_name'),
-  arguments: text('arguments'),
-  identifier: text('identifier'),
-  state: jsonb('state'),
-  error: jsonb('error'),
-  userId: text('user_id')
-    .references(() => users.id, { onDelete: 'cascade' })
-    .notNull(),
-});
+export const messagePlugins = pgTable(
+  'message_plugins',
+  {
+    id: text('id')
+      .references(() => messages.id, { onDelete: 'cascade' })
+      .primaryKey(),
+
+    toolCallId: text('tool_call_id'),
+    type: text('type', {
+      enum: ['default', 'markdown', 'standalone', 'builtin'],
+    }).default('default'),
+
+    apiName: text('api_name'),
+    arguments: text('arguments'),
+    identifier: text('identifier'),
+    state: jsonb('state'),
+    error: jsonb('error'),
+    clientId: text('client_id'),
+    userId: text('user_id')
+      .references(() => users.id, { onDelete: 'cascade' })
+      .notNull(),
+  },
+  (t) => ({
+    clientIdUnique: uniqueIndex('message_plugins_client_id_user_id_unique').on(
+      t.clientId,
+      t.userId,
+    ),
+  }),
+);
 
 export type MessagePluginItem = typeof messagePlugins.$inferSelect;
 export const updateMessagePluginSchema = createSelectSchema(messagePlugins);
 
-export const messageTTS = pgTable('message_tts', {
-  id: text('id')
-    .references(() => messages.id, { onDelete: 'cascade' })
-    .primaryKey(),
-  contentMd5: text('content_md5'),
-  fileId: text('file_id').references(() => files.id, { onDelete: 'cascade' }),
-  voice: text('voice'),
-  userId: text('user_id')
-    .references(() => users.id, { onDelete: 'cascade' })
-    .notNull(),
-});
-
-export const messageTranslates = pgTable('message_translates', {
-  id: text('id')
-    .references(() => messages.id, { onDelete: 'cascade' })
-    .primaryKey(),
-  content: text('content'),
-  from: text('from'),
-  to: text('to'),
-  userId: text('user_id')
-    .references(() => users.id, { onDelete: 'cascade' })
-    .notNull(),
-});
+export const messageTTS = pgTable(
+  'message_tts',
+  {
+    id: text('id')
+      .references(() => messages.id, { onDelete: 'cascade' })
+      .primaryKey(),
+    contentMd5: text('content_md5'),
+    fileId: text('file_id').references(() => files.id, { onDelete: 'cascade' }),
+    voice: text('voice'),
+    clientId: text('client_id'),
+    userId: text('user_id')
+      .references(() => users.id, { onDelete: 'cascade' })
+      .notNull(),
+  },
+  (t) => ({
+    clientIdUnique: uniqueIndex('message_tts_client_id_user_id_unique').on(t.clientId, t.userId),
+  }),
+);
+
+export const messageTranslates = pgTable(
+  'message_translates',
+  {
+    id: text('id')
+      .references(() => messages.id, { onDelete: 'cascade' })
+      .primaryKey(),
+    content: text('content'),
+    from: text('from'),
+    to: text('to'),
+    clientId: text('client_id'),
+    userId: text('user_id')
+      .references(() => users.id, { onDelete: 'cascade' })
+      .notNull(),
+  },
+  (t) => ({
+    clientIdUnique: uniqueIndex('message_translates_client_id_user_id_unique').on(
+      t.clientId,
+      t.userId,
+    ),
+  }),
+);
 
 // if the message contains a file
 // save the file id and message id
@@ -147,18 +174,28 @@ export const messagesFiles = pgTable(
   }),
 );
 
-export const messageQueries = pgTable('message_queries', {
-  id: uuid('id').defaultRandom().primaryKey(),
-  messageId: text('message_id')
-    .references(() => messages.id, { onDelete: 'cascade' })
-    .notNull(),
-  rewriteQuery: text('rewrite_query'),
-  userQuery: text('user_query'),
-  userId: text('user_id')
-    .references(() => users.id, { onDelete: 'cascade' })
-    .notNull(),
-  embeddingsId: uuid('embeddings_id').references(() => embeddings.id, { onDelete: 'set null' }),
-});
+export const messageQueries = pgTable(
+  'message_queries',
+  {
+    id: uuid('id').defaultRandom().primaryKey(),
+    messageId: text('message_id')
+      .references(() => messages.id, { onDelete: 'cascade' })
+      .notNull(),
+    rewriteQuery: text('rewrite_query'),
+    userQuery: text('user_query'),
+    clientId: text('client_id'),
+    userId: text('user_id')
+      .references(() => users.id, { onDelete: 'cascade' })
+      .notNull(),
+    embeddingsId: uuid('embeddings_id').references(() => embeddings.id, { onDelete: 'set null' }),
+  },
+  (t) => ({
+    clientIdUnique: uniqueIndex('message_queries_client_id_user_id_unique').on(
+      t.clientId,
+      t.userId,
+    ),
+  }),
+);
 
 export type NewMessageQuery = typeof messageQueries.$inferInsert;
 

package/src/database/schemas/rag.ts

@@ -1,51 +1,84 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix  */
-import { integer, jsonb, pgTable, text, uuid, varchar, vector } from 'drizzle-orm/pg-core';
+import {
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  uniqueIndex,
+  uuid,
+  varchar,
+  vector,
+} from 'drizzle-orm/pg-core';
 
 import { timestamps } from './_helpers';
 import { files } from './file';
 import { users } from './user';
 
-export const chunks = pgTable('chunks', {
-  id: uuid('id').defaultRandom().primaryKey(),
-  text: text('text'),
-  abstract: text('abstract'),
-  metadata: jsonb('metadata'),
-  index: integer('index'),
-  type: varchar('type'),
+export const chunks = pgTable(
+  'chunks',
+  {
+    id: uuid('id').defaultRandom().primaryKey(),
+    text: text('text'),
+    abstract: text('abstract'),
+    metadata: jsonb('metadata'),
+    index: integer('index'),
+    type: varchar('type'),
 
-  userId: text('user_id').references(() => users.id, { onDelete: 'cascade' }),
+    clientId: text('client_id'),
+    userId: text('user_id').references(() => users.id, { onDelete: 'cascade' }),
 
-  ...timestamps,
-});
+    ...timestamps,
+  },
+  (t) => ({
+    clientIdUnique: uniqueIndex('chunks_client_id_user_id_unique').on(t.clientId, t.userId),
+  }),
+);
 
 export type NewChunkItem = typeof chunks.$inferInsert & { fileId?: string };
 
-export const unstructuredChunks = pgTable('unstructured_chunks', {
-  id: uuid('id').defaultRandom().primaryKey(),
-  text: text('text'),
-  metadata: jsonb('metadata'),
-  index: integer('index'),
-  type: varchar('type'),
+export const unstructuredChunks = pgTable(
+  'unstructured_chunks',
+  {
+    id: uuid('id').defaultRandom().primaryKey(),
+    text: text('text'),
+    metadata: jsonb('metadata'),
+    index: integer('index'),
+    type: varchar('type'),
 
-  ...timestamps,
+    ...timestamps,
 
-  parentId: varchar('parent_id'),
-  compositeId: uuid('composite_id').references(() => chunks.id, { onDelete: 'cascade' }),
-  userId: text('user_id').references(() => users.id, { onDelete: 'cascade' }),
-  fileId: varchar('file_id').references(() => files.id, { onDelete: 'cascade' }),
-});
+    parentId: varchar('parent_id'),
+    compositeId: uuid('composite_id').references(() => chunks.id, { onDelete: 'cascade' }),
+    clientId: text('client_id'),
+    userId: text('user_id').references(() => users.id, { onDelete: 'cascade' }),
+    fileId: varchar('file_id').references(() => files.id, { onDelete: 'cascade' }),
+  },
+  (t) => ({
+    clientIdUnique: uniqueIndex('unstructured_chunks_client_id_user_id_unique').on(
+      t.clientId,
+      t.userId,
+    ),
+  }),
+);
 
 export type NewUnstructuredChunkItem = typeof unstructuredChunks.$inferInsert;
 
-export const embeddings = pgTable('embeddings', {
-  id: uuid('id').defaultRandom().primaryKey(),
-  chunkId: uuid('chunk_id')
-    .references(() => chunks.id, { onDelete: 'cascade' })
-    .unique(),
-  embeddings: vector('embeddings', { dimensions: 1024 }),
-  model: text('model'),
-  userId: text('user_id').references(() => users.id, { onDelete: 'cascade' }),
-});
+export const embeddings = pgTable(
+  'embeddings',
+  {
+    id: uuid('id').defaultRandom().primaryKey(),
+    chunkId: uuid('chunk_id')
+      .references(() => chunks.id, { onDelete: 'cascade' })
+      .unique(),
+    embeddings: vector('embeddings', { dimensions: 1024 }),
+    model: text('model'),
+    clientId: text('client_id'),
+    userId: text('user_id').references(() => users.id, { onDelete: 'cascade' }),
+  },
+  (t) => ({
+    clientIdUnique: uniqueIndex('embeddings_client_id_user_id_unique').on(t.clientId, t.userId),
+  }),
+);
 
 export type NewEmbeddingsItem = typeof embeddings.$inferInsert;
 export type EmbeddingsSelectItem = typeof embeddings.$inferSelect;

package/src/database/schemas/session.ts

@@ -1,5 +1,5 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix  */
-import { boolean, integer, pgTable, text, unique, uniqueIndex, varchar } from 'drizzle-orm/pg-core';
+import { boolean, integer, pgTable, text, uniqueIndex, varchar } from 'drizzle-orm/pg-core';
 import { createInsertSchema } from 'drizzle-zod';
 
 import { idGenerator, randomSlug } from '@/database/utils/idGenerator';
@@ -26,7 +26,10 @@ export const sessionGroups = pgTable(
     ...timestamps,
   },
   (table) => ({
-    clientIdUnique: unique('session_group_client_id_user_unique').on(table.clientId, table.userId),
+    clientIdUnique: uniqueIndex('session_groups_client_id_user_id_unique').on(
+      table.clientId,
+      table.userId,
+    ),
   }),
 );
 
@@ -65,7 +68,7 @@ export const sessions = pgTable(
   (t) => ({
     slugUserIdUnique: uniqueIndex('slug_user_id_unique').on(t.slug, t.userId),
 
-    clientIdUnique: unique('sessions_client_id_user_id_unique').on(t.clientId, t.userId),
+    clientIdUnique: uniqueIndex('sessions_client_id_user_id_unique').on(t.clientId, t.userId),
   }),
 );
 

package/src/database/schemas/topic.ts

@@ -1,5 +1,5 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix  */
-import { boolean, jsonb, pgTable, text, unique } from 'drizzle-orm/pg-core';
+import { boolean, jsonb, pgTable, text, uniqueIndex } from 'drizzle-orm/pg-core';
 import { createInsertSchema } from 'drizzle-zod';
 
 import { idGenerator } from '@/database/utils/idGenerator';
@@ -27,7 +27,7 @@ export const topics = pgTable(
     ...timestamps,
   },
   (t) => ({
-    clientIdUnique: unique('topic_client_id_user_id_unique').on(t.clientId, t.userId),
+    clientIdUnique: uniqueIndex('topics_client_id_user_id_unique').on(t.clientId, t.userId),
   }),
 );
 
@@ -35,28 +35,35 @@ export type NewTopic = typeof topics.$inferInsert;
 export type TopicItem = typeof topics.$inferSelect;
 
 // @ts-ignore
-export const threads = pgTable('threads', {
-  id: text('id')
-    .$defaultFn(() => idGenerator('threads', 16))
-    .primaryKey(),
-
-  title: text('title'),
-  type: text('type', { enum: ['continuation', 'standalone'] }).notNull(),
-  status: text('status', { enum: ['active', 'deprecated', 'archived'] }).default('active'),
-  topicId: text('topic_id')
-    .references(() => topics.id, { onDelete: 'cascade' })
-    .notNull(),
-  sourceMessageId: text('source_message_id').notNull(),
-  // @ts-ignore
-  parentThreadId: text('parent_thread_id').references(() => threads.id, { onDelete: 'set null' }),
-
-  userId: text('user_id')
-    .references(() => users.id, { onDelete: 'cascade' })
-    .notNull(),
-
-  lastActiveAt: timestamptz('last_active_at').defaultNow(),
-  ...timestamps,
-});
+export const threads = pgTable(
+  'threads',
+  {
+    id: text('id')
+      .$defaultFn(() => idGenerator('threads', 16))
+      .primaryKey(),
+
+    title: text('title'),
+    type: text('type', { enum: ['continuation', 'standalone'] }).notNull(),
+    status: text('status', { enum: ['active', 'deprecated', 'archived'] }).default('active'),
+    topicId: text('topic_id')
+      .references(() => topics.id, { onDelete: 'cascade' })
+      .notNull(),
+    sourceMessageId: text('source_message_id').notNull(),
+    // @ts-ignore
+    parentThreadId: text('parent_thread_id').references(() => threads.id, { onDelete: 'set null' }),
+    clientId: text('client_id'),
+
+    userId: text('user_id')
+      .references(() => users.id, { onDelete: 'cascade' })
+      .notNull(),
+
+    lastActiveAt: timestamptz('last_active_at').defaultNow(),
+    ...timestamps,
+  },
+  (t) => ({
+    clientIdUnique: uniqueIndex('threads_client_id_user_id_unique').on(t.clientId, t.userId),
+  }),
+);
 
 export type NewThread = typeof threads.$inferInsert;
 export type ThreadItem = typeof threads.$inferSelect;