Open Yufu Feishu Knowledge Base Permissions (#4867)

* add feishu yuque dataset

* Open Yufu Feishu Knowledge Base Permissions

* Refactor the dataset request module, optimize the import path, and fix the type definition

---------

Co-authored-by: dreamer6680 <146868355@qq.com>

packages/service/common/api/type.d.ts

@@ -6,12 +6,6 @@ import type {
 } from '../../core/dataset/search/controller';
 import type { AuthOpenApiLimitProps } from '../../support/openapi/auth';
 import type { CreateUsageProps, ConcatUsageProps } from '@fastgpt/global/support/wallet/usage/api';
-import type {
-  GetProApiDatasetFileContentParams,
-  GetProApiDatasetFileDetailParams,
-  GetProApiDatasetFileListParams,
-  GetProApiDatasetFilePreviewUrlParams
-} from '../../core/dataset/apiDataset/proApi';
 
 declare global {
   var textCensorHandler: (params: { text: string }) => Promise<{ code: number; message?: string }>;
@@ -19,16 +13,4 @@ declare global {
   var authOpenApiHandler: (data: AuthOpenApiLimitProps) => Promise<any>;
   var createUsageHandler: (data: CreateUsageProps) => any;
   var concatUsageHandler: (data: ConcatUsageProps) => any;
-
-  // API dataset
-  var getProApiDatasetFileList: (data: GetProApiDatasetFileListParams) => Promise<APIFileItem[]>;
-  var getProApiDatasetFileContent: (
-    data: GetProApiDatasetFileContentParams
-  ) => Promise<ApiFileReadContentResponse>;
-  var getProApiDatasetFilePreviewUrl: (
-    data: GetProApiDatasetFilePreviewUrlParams
-  ) => Promise<string>;
-  var getProApiDatasetFileDetail: (
-    data: GetProApiDatasetFileDetailParams
-  ) => Promise<ApiDatasetDetailResponse>;
 }

packages/service/core/dataset/apiDataset/index.ts

+import type {
+  APIFileServer,
+  YuqueServer,
+  FeishuServer
+} from '@fastgpt/global/core/dataset/apiDataset';
+import { useApiDatasetRequest } from './api';
+import { useYuqueDatasetRequest } from '../yuqueDataset/api';
+import { useFeishuDatasetRequest } from '../feishuDataset/api';
+
+export const getApiDatasetRequest = async (data: {
+  apiServer?: APIFileServer;
+  yuqueServer?: YuqueServer;
+  feishuServer?: FeishuServer;
+}) => {
+  const { apiServer, yuqueServer, feishuServer } = data;
+
+  if (apiServer) {
+    return useApiDatasetRequest({ apiServer });
+  }
+  if (yuqueServer) {
+    return useYuqueDatasetRequest({ yuqueServer });
+  }
+  if (feishuServer) {
+    return useFeishuDatasetRequest({ feishuServer });
+  }
+  return Promise.reject('Can not find api dataset server');
+};

packages/service/core/dataset/apiDataset/proApi.ts

-import { type ParentIdType } from '@fastgpt/global/common/parentFolder/type';
-import { type FeishuServer, type YuqueServer } from '@fastgpt/global/core/dataset/apiDataset';
-
-export enum ProApiDatasetOperationTypeEnum {
-  LIST = 'list',
-  READ = 'read',
-  CONTENT = 'content',
-  DETAIL = 'detail'
-}
-
-export type ProApiDatasetCommonParams = {
-  feishuServer?: FeishuServer;
-  yuqueServer?: YuqueServer;
-};
-
-export type GetProApiDatasetFileListParams = ProApiDatasetCommonParams & {
-  parentId?: ParentIdType;
-};
-
-export type GetProApiDatasetFileContentParams = ProApiDatasetCommonParams & {
-  apiFileId: string;
-};
-
-export type GetProApiDatasetFilePreviewUrlParams = ProApiDatasetCommonParams & {
-  apiFileId: string;
-};
-
-export type GetProApiDatasetFileDetailParams = ProApiDatasetCommonParams & {
-  apiFileId: string;
-};

packages/service/core/dataset/feishuDataset/api.ts

+import type {
+  APIFileItem,
+  ApiFileReadContentResponse,
+  ApiDatasetDetailResponse,
+  FeishuServer
+} from '@fastgpt/global/core/dataset/apiDataset';
+import { type ParentIdType } from '@fastgpt/global/common/parentFolder/type';
+import axios, { type Method } from 'axios';
+import { addLog } from '../../../common/system/log';
+
+type ResponseDataType = {
+  success: boolean;
+  message: string;
+  data: any;
+};
+
+type FeishuFileListResponse = {
+  files: {
+    token: string;
+    parent_token: string;
+    name: string;
+    type: string;
+    modified_time: number;
+    created_time: number;
+    url: string;
+    owner_id: string;
+  }[];
+  has_more: boolean;
+  next_page_token: string;
+};
+
+const feishuBaseUrl = process.env.FEISHU_BASE_URL || 'https://open.feishu.cn';
+
+export const useFeishuDatasetRequest = ({ feishuServer }: { feishuServer: FeishuServer }) => {
+  const instance = axios.create({
+    baseURL: feishuBaseUrl,
+    timeout: 60000
+  });
+
+  // 添加请求拦截器
+  instance.interceptors.request.use(async (config) => {
+    if (!config.headers.Authorization) {
+      const { data } = await axios.post<{ tenant_access_token: string }>(
+        `${feishuBaseUrl}/open-apis/auth/v3/tenant_access_token/internal`,
+        {
+          app_id: feishuServer.appId,
+          app_secret: feishuServer.appSecret
+        }
+      );
+
+      config.headers['Authorization'] = `Bearer ${data.tenant_access_token}`;
+      config.headers['Content-Type'] = 'application/json; charset=utf-8';
+    }
+    return config;
+  });
+
+  /**
+   * 响应数据检查
+   */
+  const checkRes = (data: ResponseDataType) => {
+    if (data === undefined) {
+      addLog.info('yuque dataset data is empty');
+      return Promise.reject('服务器异常');
+    }
+    return data.data;
+  };
+  const responseError = (err: any) => {
+    console.log('error->', '请求错误', err);
+
+    if (!err) {
+      return Promise.reject({ message: '未知错误' });
+    }
+    if (typeof err === 'string') {
+      return Promise.reject({ message: err });
+    }
+    if (typeof err.message === 'string') {
+      return Promise.reject({ message: err.message });
+    }
+    if (typeof err.data === 'string') {
+      return Promise.reject({ message: err.data });
+    }
+    if (err?.response?.data) {
+      return Promise.reject(err?.response?.data);
+    }
+    return Promise.reject(err);
+  };
+
+  const request = <T>(url: string, data: any, method: Method): Promise<T> => {
+    /* 去空 */
+    for (const key in data) {
+      if (data[key] === undefined) {
+        delete data[key];
+      }
+    }
+
+    return instance
+      .request({
+        url,
+        method,
+        data: ['POST', 'PUT'].includes(method) ? data : undefined,
+        params: !['POST', 'PUT'].includes(method) ? data : undefined
+      })
+      .then((res) => checkRes(res.data))
+      .catch((err) => responseError(err));
+  };
+
+  const listFiles = async ({ parentId }: { parentId?: ParentIdType }): Promise<APIFileItem[]> => {
+    const fetchFiles = async (pageToken?: string): Promise<FeishuFileListResponse['files']> => {
+      const data = await request<FeishuFileListResponse>(
+        `/open-apis/drive/v1/files`,
+        {
+          folder_token: parentId || feishuServer.folderToken,
+          page_size: 200,
+          page_token: pageToken
+        },
+        'GET'
+      );
+
+      if (data.has_more) {
+        const nextFiles = await fetchFiles(data.next_page_token);
+        return [...data.files, ...nextFiles];
+      }
+
+      return data.files;
+    };
+
+    const allFiles = await fetchFiles();
+
+    return allFiles
+      .filter((file) => ['folder', 'docx'].includes(file.type))
+      .map((file) => ({
+        id: file.token,
+        parentId: file.parent_token,
+        name: file.name,
+        type: file.type === 'folder' ? ('folder' as const) : ('file' as const),
+        hasChild: file.type === 'folder',
+        updateTime: new Date(file.modified_time * 1000),
+        createTime: new Date(file.created_time * 1000)
+      }));
+  };
+
+  const getFileContent = async ({
+    apiFileId
+  }: {
+    apiFileId: string;
+  }): Promise<ApiFileReadContentResponse> => {
+    const [{ content }, { document }] = await Promise.all([
+      request<{ content: string }>(
+        `/open-apis/docx/v1/documents/${apiFileId}/raw_content`,
+        {},
+        'GET'
+      ),
+      request<{ document: { title: string } }>(
+        `/open-apis/docx/v1/documents/${apiFileId}`,
+        {},
+        'GET'
+      )
+    ]);
+
+    return {
+      title: document?.title,
+      rawText: content
+    };
+  };
+
+  const getFilePreviewUrl = async ({ apiFileId }: { apiFileId: string }): Promise<string> => {
+    const { metas } = await request<{ metas: { url: string }[] }>(
+      `/open-apis/drive/v1/metas/batch_query`,
+      {
+        request_docs: [
+          {
+            doc_token: apiFileId,
+            doc_type: 'docx'
+          }
+        ],
+        with_url: true
+      },
+      'POST'
+    );
+
+    return metas[0].url;
+  };
+
+  const getFileDetail = async ({
+    apiFileId
+  }: {
+    apiFileId: string;
+  }): Promise<ApiDatasetDetailResponse> => {
+    const { document } = await request<{ document: { title: string } }>(
+      `/open-apis/docx/v1/documents/${apiFileId}`,
+      {},
+      'GET'
+    );
+
+    return {
+      name: document?.title,
+      parentId: null,
+      id: apiFileId
+    };
+  };
+
+  return {
+    getFileContent,
+    listFiles,
+    getFilePreviewUrl,
+    getFileDetail
+  };
+};

packages/service/core/dataset/read.ts

@@ -11,7 +11,7 @@ import {
   type FeishuServer,
   type YuqueServer
 } from '@fastgpt/global/core/dataset/apiDataset';
-import { useApiDatasetRequest } from './apiDataset/api';
+import { getApiDatasetRequest } from './apiDataset';
 import Papa from 'papaparse';
 
 export const readFileRawTextByUrl = async ({
@@ -163,24 +163,22 @@ export const readApiServerFileContent = async ({
   title?: string;
   rawText: string;
 }> => {
-  if (apiServer) {
-    return useApiDatasetRequest({ apiServer }).getFileContent({
-      teamId,
-      tmbId,
-      apiFileId,
-      customPdfParse
-    });
-  }
-
-  if (feishuServer || yuqueServer) {
-    return global.getProApiDatasetFileContent({
-      feishuServer,
+  const data = (
+    await getApiDatasetRequest({
+      apiServer,
       yuqueServer,
-      apiFileId
-    });
+      feishuServer
+    })
+  ).getFileContent({
+    teamId,
+    tmbId,
+    apiFileId,
+    customPdfParse
+  });
+  if (data) {
+    return data;
   }
-
-  return Promise.reject('No apiServer or feishuServer or yuqueServer');
+  return Promise.reject(Error);
 };
 
 export const rawText2Chunks = ({

packages/service/core/dataset/yuqueDataset/api.ts

+import type {
+  APIFileItem,
+  ApiFileReadContentResponse,
+  YuqueServer,
+  ApiDatasetDetailResponse
+} from '@fastgpt/global/core/dataset/apiDataset';
+import axios, { type Method } from 'axios';
+import { addLog } from '../../../common/system/log';
+import { type ParentIdType } from '@fastgpt/global/common/parentFolder/type';
+
+type ResponseDataType = {
+  success: boolean;
+  message: string;
+  data: any;
+};
+
+type YuqueRepoListResponse = {
+  id: string;
+  name: string;
+  title: string;
+  book_id: string | null;
+  type: string;
+  updated_at: Date;
+  created_at: Date;
+  slug?: string;
+}[];
+
+type YuqueTocListResponse = {
+  uuid: string;
+  type: string;
+  title: string;
+  url: string;
+  slug: string;
+  id: string;
+  doc_id: string;
+  prev_uuid: string;
+  sibling_uuid: string;
+  child_uuid: string;
+  parent_uuid: string;
+}[];
+
+const yuqueBaseUrl = process.env.YUQUE_DATASET_BASE_URL || 'https://www.yuque.com';
+
+export const useYuqueDatasetRequest = ({ yuqueServer }: { yuqueServer: YuqueServer }) => {
+  const instance = axios.create({
+    baseURL: yuqueBaseUrl,
+    timeout: 60000, // 超时时间
+    headers: {
+      'X-Auth-Token': yuqueServer.token
+    }
+  });
+
+  /**
+   * 响应数据检查
+   */
+  const checkRes = (data: ResponseDataType) => {
+    if (data === undefined) {
+      addLog.info('yuque dataset data is empty');
+      return Promise.reject('服务器异常');
+    }
+    return data.data;
+  };
+  const responseError = (err: any) => {
+    console.log('error->', '请求错误', err);
+
+    if (!err) {
+      return Promise.reject({ message: '未知错误' });
+    }
+    if (typeof err === 'string') {
+      return Promise.reject({ message: err });
+    }
+    if (typeof err.message === 'string') {
+      return Promise.reject({ message: err.message });
+    }
+    if (typeof err.data === 'string') {
+      return Promise.reject({ message: err.data });
+    }
+    if (err?.response?.data) {
+      return Promise.reject(err?.response?.data);
+    }
+    return Promise.reject(err);
+  };
+
+  const request = <T>(url: string, data: any, method: Method): Promise<T> => {
+    /* 去空 */
+    for (const key in data) {
+      if (data[key] === undefined) {
+        delete data[key];
+      }
+    }
+
+    return instance
+      .request({
+        url,
+        method,
+        data: ['POST', 'PUT'].includes(method) ? data : undefined,
+        params: !['POST', 'PUT'].includes(method) ? data : undefined
+      })
+      .then((res) => checkRes(res.data))
+      .catch((err) => responseError(err));
+  };
+
+  const listFiles = async ({ parentId }: { parentId?: ParentIdType }) => {
+    // Auto set baseurl to parentId
+    if (!parentId) {
+      if (yuqueServer.basePath) parentId = yuqueServer.basePath;
+    }
+
+    let files: APIFileItem[] = [];
+
+    if (!parentId) {
+      const limit = 100;
+      let offset = 0;
+      let allData: YuqueRepoListResponse = [];
+
+      while (true) {
+        const data = await request<YuqueRepoListResponse>(
+          `/api/v2/groups/${yuqueServer.userId}/repos`,
+          {
+            offset,
+            limit
+          },
+          'GET'
+        );
+
+        if (!data || data.length === 0) break;
+
+        allData = [...allData, ...data];
+        if (data.length < limit) break;
+
+        offset += limit;
+      }
+
+      files = allData.map((item) => {
+        return {
+          id: item.id,
+          name: item.name,
+          parentId: null,
+          type: 'folder',
+          updateTime: item.updated_at,
+          createTime: item.created_at,
+          hasChild: true,
+          slug: item.slug
+        };
+      });
+    } else {
+      if (typeof parentId === 'number') {
+        const data = await request<YuqueTocListResponse>(
+          `/api/v2/repos/${parentId}/toc`,
+          {},
+          'GET'
+        );
+
+        return data
+          .filter((item) => !item.parent_uuid && item.type !== 'LINK')
+          .map((item) => ({
+            id: `${parentId}-${item.id}-${item.uuid}`,
+            name: item.title,
+            parentId: item.parent_uuid,
+            type: item.type === 'TITLE' ? ('folder' as const) : ('file' as const),
+            updateTime: new Date(),
+            createTime: new Date(),
+            uuid: item.uuid,
+            slug: item.slug,
+            hasChild: !!item.child_uuid
+          }));
+      } else {
+        const [repoId, uuid, parentUuid] = parentId.split(/-(.*?)-(.*)/);
+        const data = await request<YuqueTocListResponse>(`/api/v2/repos/${repoId}/toc`, {}, 'GET');
+
+        return data
+          .filter((item) => item.parent_uuid === parentUuid)
+          .map((item) => ({
+            id: `${repoId}-${item.id}-${item.uuid}`,
+            name: item.title,
+            parentId: item.parent_uuid,
+            type: item.type === 'TITLE' ? ('folder' as const) : ('file' as const),
+            updateTime: new Date(),
+            createTime: new Date(),
+            uuid: item.uuid,
+            slug: item.slug,
+            hasChild: !!item.child_uuid
+          }));
+      }
+    }
+
+    if (!Array.isArray(files)) {
+      return Promise.reject('Invalid file list format');
+    }
+    if (files.some((file) => !file.id || !file.name || typeof file.type === 'undefined')) {
+      return Promise.reject('Invalid file data format');
+    }
+    return files;
+  };
+
+  const getFileContent = async ({
+    apiFileId
+  }: {
+    apiFileId: string;
+  }): Promise<ApiFileReadContentResponse> => {
+    const [parentId, fileId] = apiFileId.split(/-(.*?)-(.*)/);
+
+    const data = await request<{ title: string; body: string }>(
+      `/api/v2/repos/${parentId}/docs/${fileId}`,
+      {},
+      'GET'
+    );
+
+    return {
+      title: data.title,
+      rawText: data.body
+    };
+  };
+
+  const getFilePreviewUrl = async ({ apiFileId }: { apiFileId: string }) => {
+    const [parentId, fileId] = apiFileId.split(/-(.*?)-(.*)/);
+
+    const { slug: parentSlug } = await request<{ slug: string }>(
+      `/api/v2/repos/${parentId}`,
+      { id: apiFileId },
+      'GET'
+    );
+
+    const { slug: fileSlug } = await request<{ slug: string }>(
+      `/api/v2/repos/${parentId}/docs/${fileId}`,
+      {},
+      'GET'
+    );
+
+    return `${yuqueBaseUrl}/${yuqueServer.userId}/${parentSlug}/${fileSlug}`;
+  };
+
+  const getFileDetail = async ({
+    apiFileId
+  }: {
+    apiFileId: string;
+  }): Promise<ApiDatasetDetailResponse> => {
+    //如果id是数字，认为是知识库，获取知识库列表
+    if (typeof apiFileId === 'number' || !isNaN(Number(apiFileId))) {
+      const limit = 100;
+      let offset = 0;
+      let allData: YuqueRepoListResponse = [];
+
+      while (true) {
+        const data = await request<YuqueRepoListResponse>(
+          `/api/v2/groups/${yuqueServer.userId}/repos`,
+          {
+            offset,
+            limit
+          },
+          'GET'
+        );
+
+        if (!data || data.length === 0) break;
+
+        allData = [...allData, ...data];
+        if (data.length < limit) break;
+
+        offset += limit;
+      }
+
+      const file = allData.find((item) => Number(item.id) === Number(apiFileId));
+      if (!file) {
+        return Promise.reject('文件不存在');
+      }
+      return {
+        id: file.id,
+        name: file.name,
+        parentId: null
+      };
+    } else {
+      const [repoId, parentUuid, fileId] = apiFileId.split(/-(.*?)-(.*)/);
+      const data = await request<YuqueTocListResponse>(`/api/v2/repos/${repoId}/toc`, {}, 'GET');
+      const file = data.find((item) => item.uuid === fileId);
+      if (!file) {
+        return Promise.reject('文件不存在');
+      }
+      const parentfile = data.find((item) => item.uuid === file.parent_uuid);
+      const parentId = `${repoId}-${parentfile?.id}-${parentfile?.uuid}`;
+
+      //判断如果parent_uuid为空，则认为是知识库的根目录，返回知识库
+      if (file.parent_uuid) {
+        return {
+          id: file.id,
+          name: file.title,
+          parentId: parentId
+        };
+      } else {
+        return {
+          id: file.id,
+          name: file.title,
+          parentId: repoId
+        };
+      }
+    }
+  };
+
+  return {
+    getFileContent,
+    listFiles,
+    getFilePreviewUrl,
+    getFileDetail
+  };
+};

projects/app/src/pages/api/core/dataset/apiDataset/getCatalog.ts

-import { getProApiDatasetFileListRequest } from '@/service/core/dataset/apiDataset/controller';
+import { getApiDatasetRequest } from '@fastgpt/service/core/dataset/apiDataset';
 import { NextAPI } from '@/service/middleware/entry';
-import { DatasetErrEnum } from '@fastgpt/global/common/error/code/dataset';
 import type { ParentIdType } from '@fastgpt/global/common/parentFolder/type';
 import type {
   APIFileItem,
@@ -8,12 +7,10 @@ import type {
   YuqueServer,
   FeishuServer
 } from '@fastgpt/global/core/dataset/apiDataset';
-import { useApiDatasetRequest } from '@fastgpt/service/core/dataset/apiDataset/api';
 import { type NextApiRequest } from 'next';
 import { authCert } from '@fastgpt/service/support/permission/auth/common';
 
 export type GetApiDatasetCataLogProps = {
-  searchKey?: string;
   parentId?: ParentIdType;
   yuqueServer?: YuqueServer;
   feishuServer?: FeishuServer;
@@ -27,21 +24,15 @@ async function handler(req: NextApiRequest) {
 
   await authCert({ req, authToken: true });
 
-  const data = await (async () => {
-    if (apiServer) {
-      return useApiDatasetRequest({ apiServer }).listFiles({ searchKey, parentId });
-    }
-    if (feishuServer || yuqueServer) {
-      return getProApiDatasetFileListRequest({
-        feishuServer,
-        yuqueServer,
-        parentId
-      });
-    }
-    return Promise.reject(DatasetErrEnum.noApiServer);
-  })();
+  const data = await (
+    await getApiDatasetRequest({
+      feishuServer,
+      yuqueServer,
+      apiServer
+    })
+  ).listFiles({ parentId, searchKey });
 
-  return data.filter((item: APIFileItem) => item.hasChild === true);
+  return data?.filter((item: APIFileItem) => item.hasChild === true) || [];
 }
 
 export default NextAPI(handler);

projects/app/src/pages/api/core/dataset/apiDataset/getPathNames.ts

@@ -7,12 +7,11 @@ import type {
   FeishuServer,
   ApiDatasetDetailResponse
 } from '@fastgpt/global/core/dataset/apiDataset';
-import { getProApiDatasetFileDetailRequest } from '@/service/core/dataset/apiDataset/controller';
+import { getApiDatasetRequest } from '@fastgpt/service/core/dataset/apiDataset';
 import type { ApiRequestProps, ApiResponseType } from '@fastgpt/service/type/next';
 import { authCert } from '@fastgpt/service/support/permission/auth/common';
 import { authDataset } from '@fastgpt/service/support/permission/dataset/auth';
 import { ManagePermissionVal } from '@fastgpt/global/support/permission/constant';
-import { useApiDatasetRequest } from '@fastgpt/service/core/dataset/apiDataset/api';
 
 export type GetApiDatasetPathQuery = {};
 
@@ -86,26 +85,21 @@ async function handler(
     }
   })();
 
-  if (!apiServer && !feishuServer && !yuqueServer) {
-    return Promise.reject(DatasetErrEnum.noApiServer);
-  }
-
   if (feishuServer) {
     return '';
   }
 
-  if (apiServer) {
-    return await getFullPath(parentId, useApiDatasetRequest({ apiServer }).getFileDetail);
-  }
+  if (yuqueServer || apiServer) {
+    const apiDataset = await getApiDatasetRequest({
+      yuqueServer,
+      apiServer
+    });
 
-  if (yuqueServer) {
-    const yuqueFileGetter = async ({ apiFileId }: { apiFileId: string }) => {
-      return await getProApiDatasetFileDetailRequest({
-        yuqueServer,
-        apiFileId
-      });
-    };
-    return await getFullPath(parentId, yuqueFileGetter);
+    if (!apiDataset?.getFileDetail) {
+      return Promise.reject(DatasetErrEnum.noApiServer);
+    }
+
+    return await getFullPath(parentId, apiDataset.getFileDetail);
   }
 
   return Promise.reject(new Error(DatasetErrEnum.noApiServer));

projects/app/src/pages/api/core/dataset/apiDataset/list.ts

@@ -2,7 +2,7 @@ import { NextAPI } from '@/service/middleware/entry';
 import { DatasetErrEnum } from '@fastgpt/global/common/error/code/dataset';
 import { type ParentIdType } from '@fastgpt/global/common/parentFolder/type';
 import { ReadPermissionVal } from '@fastgpt/global/support/permission/constant';
-import { useApiDatasetRequest } from '@fastgpt/service/core/dataset/apiDataset/api';
+import { getApiDatasetRequest } from '@fastgpt/service/core/dataset/apiDataset';
 import { authDataset } from '@fastgpt/service/support/permission/dataset/auth';
 import { type NextApiRequest } from 'next';
 
@@ -27,18 +27,13 @@ async function handler(req: NextApiRequest) {
   const feishuServer = dataset.feishuServer;
   const yuqueServer = dataset.yuqueServer;
 
-  if (apiServer) {
-    return useApiDatasetRequest({ apiServer }).listFiles({ searchKey, parentId });
-  }
-  if (feishuServer || yuqueServer) {
-    return global.getProApiDatasetFileList({
-      feishuServer,
+  return (
+    await getApiDatasetRequest({
+      apiServer,
       yuqueServer,
-      parentId
-    });
-  }
-
-  return Promise.reject(DatasetErrEnum.noApiServer);
+      feishuServer
+    })
+  ).listFiles({ searchKey, parentId });
 }
 
 export default NextAPI(handler);

projects/app/src/pages/api/core/dataset/collection/read.ts

@@ -9,7 +9,7 @@ import { type OutLinkChatAuthProps } from '@fastgpt/global/support/permission/ch
 import { DatasetErrEnum } from '@fastgpt/global/common/error/code/dataset';
 import { authChatCrud, authCollectionInChat } from '@/service/support/permission/auth/chat';
 import { getCollectionWithDataset } from '@fastgpt/service/core/dataset/controller';
-import { useApiDatasetRequest } from '@fastgpt/service/core/dataset/apiDataset/api';
+import { getApiDatasetRequest } from '@fastgpt/service/core/dataset/apiDataset';
 
 export type readCollectionSourceQuery = {};
 
@@ -98,21 +98,15 @@ async function handler(
       const feishuServer = collection.dataset.feishuServer;
       const yuqueServer = collection.dataset.yuqueServer;
 
-      if (apiServer) {
-        return useApiDatasetRequest({ apiServer }).getFilePreviewUrl({
-          apiFileId: collection.apiFileId
-        });
-      }
-
-      if (feishuServer || yuqueServer) {
-        return global.getProApiDatasetFilePreviewUrl({
-          apiFileId: collection.apiFileId,
+      return (
+        await getApiDatasetRequest({
+          apiServer,
           feishuServer,
           yuqueServer
-        });
-      }
-
-      return '';
+        })
+      ).getFilePreviewUrl({
+        apiFileId: collection.apiFileId
+      });
     }
     if (collection.type === DatasetCollectionTypeEnum.externalFile) {
       if (collection.externalFileId && collection.dataset.externalReadUrl) {

projects/app/src/pages/dataset/list/index.tsx

@@ -66,10 +66,7 @@ const Dataset = () => {
 
   const onSelectDatasetType = useCallback(
     (e: CreateDatasetType) => {
-      if (
-        !feConfigs?.isPlus &&
-        [DatasetTypeEnum.websiteDataset, DatasetTypeEnum.feishu, DatasetTypeEnum.yuque].includes(e)
-      ) {
+      if (!feConfigs?.isPlus && [DatasetTypeEnum.websiteDataset].includes(e)) {
         return toast({
           status: 'warning',
           title: t('common:commercial_function_tip')

projects/app/src/service/common/system/index.ts

@@ -20,12 +20,6 @@ import {
   type ConcatUsageProps,
   type CreateUsageProps
 } from '@fastgpt/global/support/wallet/usage/api';
-import {
-  getProApiDatasetFileContentRequest,
-  getProApiDatasetFileDetailRequest,
-  getProApiDatasetFileListRequest,
-  getProApiDatasetFilePreviewUrlRequest
-} from '@/service/core/dataset/apiDataset/controller';
 import { isProVersion } from './constants';
 
 export const readConfigData = async (name: string) => {
@@ -77,11 +71,6 @@ export function initGlobalVariables() {
       if (!isProVersion()) return;
       return POST('/support/wallet/usage/concatUsage', data);
     };
-
-    global.getProApiDatasetFileList = getProApiDatasetFileListRequest;
-    global.getProApiDatasetFileContent = getProApiDatasetFileContentRequest;
-    global.getProApiDatasetFilePreviewUrl = getProApiDatasetFilePreviewUrlRequest;
-    global.getProApiDatasetFileDetail = getProApiDatasetFileDetailRequest;
   }
 
   global.communityPlugins = [];

projects/app/src/service/core/dataset/apiDataset/controller.ts

-import type {
-  APIFileItem,
-  ApiFileReadContentResponse,
-  ApiDatasetDetailResponse
-} from '@fastgpt/global/core/dataset/apiDataset';
-import { POST } from '@fastgpt/service/common/api/plusRequest';
-import {
-  type GetProApiDatasetFileContentParams,
-  type GetProApiDatasetFileDetailParams,
-  type GetProApiDatasetFileListParams,
-  type GetProApiDatasetFilePreviewUrlParams,
-  ProApiDatasetOperationTypeEnum
-} from '@fastgpt/service/core/dataset/apiDataset/proApi';
-
-export const getProApiDatasetFileListRequest = async (data: GetProApiDatasetFileListParams) => {
-  const res = await POST<APIFileItem[]>('/core/dataset/systemApiDataset', {
-    type: ProApiDatasetOperationTypeEnum.LIST,
-    ...data
-  });
-  return res;
-};
-
-export const getProApiDatasetFileContentRequest = async (
-  data: GetProApiDatasetFileContentParams
-) => {
-  const res = await POST<ApiFileReadContentResponse>('/core/dataset/systemApiDataset', {
-    type: ProApiDatasetOperationTypeEnum.CONTENT,
-    ...data
-  });
-  return res;
-};
-
-export const getProApiDatasetFilePreviewUrlRequest = async (
-  data: GetProApiDatasetFilePreviewUrlParams
-) => {
-  const res = await POST<string>('/core/dataset/systemApiDataset', {
-    type: ProApiDatasetOperationTypeEnum.READ,
-    ...data
-  });
-  return res;
-};
-
-export const getProApiDatasetFileDetailRequest = async (data: GetProApiDatasetFileDetailParams) => {
-  const res = await POST<ApiDatasetDetailResponse>('/core/dataset/systemApiDataset', {
-    type: ProApiDatasetOperationTypeEnum.DETAIL,
-    ...data
-  });
-  return res;
-};