feat: remove documents limit (#1697)

web/app/components/base/notion-page-selector/base.tsx

 import { useCallback, useEffect, useMemo, useState } from 'react'
-import { useTranslation } from 'react-i18next'
-import { useContext } from 'use-context-selector'
 import useSWR from 'swr'
 import cn from 'classnames'
 import s from './base.module.css'
 import { preImportNotionPages } from '@/service/datasets'
 import { NotionConnector } from '@/app/components/datasets/create/step-one'
 import type { DataSourceNotionPageMap, DataSourceNotionWorkspace, NotionPage } from '@/models/common'
-import { ToastContext } from '@/app/components/base/toast'
 import { useModalContext } from '@/context/modal-context'
 
 type NotionPageSelectorProps = {
   previewPageId?: string
   onPreview?: (selectedPage: NotionPage) => void
   datasetId?: string
-  countLimit: number
-  countUsed: number
 }
 
 const NotionPageSelector = ({
   previewPageId,
   onPreview,
   datasetId = '',
-  countLimit,
-  countUsed,
 }: NotionPageSelectorProps) => {
-  const { t } = useTranslation()
-  const { notify } = useContext(ToastContext)
   const { data, mutate } = useSWR({ url: '/notion/pre-import/pages', datasetId }, preImportNotionPages)
   const [prevData, setPrevData] = useState(data)
   const [searchValue, setSearchValue] = useState('')
   }, [])
   const handleSelecPages = (newSelectedPagesId: Set<string>) => {
     const selectedPages = Array.from(newSelectedPagesId).map(pageId => getPagesMapAndSelectedPagesId[0][pageId])
-    if (selectedPages.length > countLimit - countUsed) {
-      notify({ type: 'error', message: t('datasetCreation.stepOne.overCountLimit', { countLimit }) })
-      return false
-    }
+
     setSelectedPagesId(new Set(Array.from(newSelectedPagesId)))
     onSelect(selectedPages)
   }

web/app/components/datasets/create/file-uploader/index.tsx

   onFileUpdate: (fileItem: FileItem, progress: number, list: FileItem[]) => void
   onFileListUpdate?: (files: FileItem[]) => void
   onPreview: (file: File) => void
-  countLimit: number
-  countUsed: number
 }
 
 const ACCEPTS = [
   onFileUpdate,
   onFileListUpdate,
   onPreview,
-  countLimit,
-  countUsed,
 }: IFileUploaderProps) => {
   const { t } = useTranslation()
   const { notify } = useContext(ToastContext)
   const initialUpload = useCallback((files: File[]) => {
     if (!files.length)
       return false
-    if (files.length > countLimit - countUsed) {
-      notify({ type: 'error', message: t('datasetCreation.stepOne.overCountLimit', { countLimit }) })
-      return false
-    }
+
     const preparedFiles = files.map((file, index) => ({
       fileID: `file${index}-${Date.now()}`,
       file,

web/app/components/datasets/create/step-one/index.tsx

 'use client'
 import React, { useMemo, useState } from 'react'
-import useSWR from 'swr'
 import { useTranslation } from 'react-i18next'
 import cn from 'classnames'
 import FilePreview from '../file-preview'
 import Button from '@/app/components/base/button'
 import { NotionPageSelector } from '@/app/components/base/notion-page-selector'
 import { useDatasetDetailContext } from '@/context/dataset-detail'
-import { fetchDocumentsLimit } from '@/service/common'
 import { useProviderContext } from '@/context/provider-context'
 import VectorSpaceFull from '@/app/components/billing/vector-space-full'
 
   notionPages = [],
   updateNotionPages,
 }: IStepOneProps) => {
-  const { data: limitsData } = useSWR('/datasets/limit', fetchDocumentsLimit)
   const { dataset } = useDatasetDetailContext()
   const [showModal, setShowModal] = useState(false)
   const [currentFile, setCurrentFile] = useState<File | undefined>()
               </div>
             )
           }
-          {dataSourceType === DataSourceType.FILE && limitsData && (
+          {dataSourceType === DataSourceType.FILE && (
             <>
               <FileUploader
                 fileList={files}
                 onFileListUpdate={updateFileList}
                 onFileUpdate={updateFile}
                 onPreview={updateCurrentFile}
-                countLimit={limitsData.documents_limit}
-                countUsed={limitsData.documents_count}
               />
               {isShowVectorSpaceFull && (
                 <div className='max-w-[640px] mb-4'>
           {dataSourceType === DataSourceType.NOTION && (
             <>
               {!hasConnection && <NotionConnector onSetting={onSetting} />}
-              {hasConnection && limitsData && (
+              {hasConnection && (
                 <>
                   <div className='mb-8 w-[640px]'>
                     <NotionPageSelector
                       value={notionPages.map(page => page.page_id)}
                       onSelect={updateNotionPages}
                       onPreview={updateCurrentPage}
-                      countLimit={limitsData.documents_limit}
-                      countUsed={limitsData.documents_count}
                     />
                   </div>
                   {isShowVectorSpaceFull && (

web/i18n/lang/dataset-creation.en.ts

       confirmButton: 'Create',
       failed: 'Creation failed',
     },
-    overCountLimit: 'All your documents have overed limit {{countLimit}}.',
   },
   stepTwo: {
     segmentation: 'Chunk settings',

web/i18n/lang/dataset-creation.zh.ts

       confirmButton: '创建',
       failed: '创建失败',
     },
-    overCountLimit: '您的文件总数已超出限制 {{countLimit}}。',
   },
   stepTwo: {
     segmentation: '分段设置',

web/models/common.ts

   image_file_size_limit?: number | string
 }
 
-export type DocumentsLimitResponse = {
-  documents_count: number
-  documents_limit: number
-}
-
 export type InvitationResult = {
   status: 'success'
   email: string

web/service/common.ts

   CodeBasedExtension,
   CommonResponse,
   DataSourceNotion,
-  DocumentsLimitResponse,
   FileUploadConfigResponse,
   ICurrentWorkspace,
   IWorkspace,
   return get<FileUploadConfigResponse>(url)
 }
 
-export const fetchDocumentsLimit: Fetcher<DocumentsLimitResponse, string> = (url) => {
-  return get<DocumentsLimitResponse>(url)
-}
-
 export const fetchFreeQuotaVerify: Fetcher<{ result: string; flag: boolean; reason: string }, string> = (url) => {
   return get(url) as Promise<{ result: string; flag: boolean; reason: string }>
 }