@cloudbase/storage 3.1.0 → 3.1.2

package/src/index.ts

@@ -1,7 +1,685 @@
 import { ICloudbase } from '@cloudbase/types'
 import { ICloudbaseComponent } from '@cloudbase/types/component'
-import { CloudbaseStorage, COMPONENT_NAME, ICloudbaseContext } from './storage'
-import { SupabaseFileAPILikeStorage } from './supabase'
+import { Camelize, FileBody, FileObject, FileObjectV2, FileOptions, TransformOptions } from './supabase/types'
+import { isStorageError, StorageError } from './supabase/errors'
+import { constants, utils, helpers } from '@cloudbase/utilities'
+import {
+  ICloudbaseFileMetaDataRes,
+  ICloudbaseFileInfo,
+  ICloudbaseUploadFileParams,
+  ICloudbaseUploadFileResult,
+  ICloudbaseGetUploadMetadataParams,
+  ICloudbaseDeleteFileParams,
+  ICloudbaseDeleteFileResult,
+  ICloudbaseGetTempFileURLResult,
+  ICloudbaseGetTempFileURLParams,
+  ICloudbaseDownloadFileResult,
+  ICloudbaseDownloadFileParams,
+  ICloudbaseCopyFileParams,
+  ICloudbaseCopyFileResult,
+} from '@cloudbase/types/storage'
+
+enum EUploadMethod {
+  put = 'put',
+  post = 'post',
+}
+
+interface IUploadMetadata {
+  url: string
+  token: string
+  authorization: string
+  fileId: string
+  cosFileId: string
+  download_url?: string
+}
+
+const { getSdkName, ERRORS, COMMUNITY_SITE_URL } = constants
+const { isArray, isString, isPalinObject, execCallback } = utils
+/** catchErrorsDecorator 装饰器要放在index入口文件，意面有的编译找不到其sourcemap，例如HBuilderX */
+const { catchErrorsDecorator } = helpers
+
+export const COMPONENT_NAME = 'storage'
+
+const storageGateWay = {
+  getUploadInfo: async (
+    request,
+    params: { path: string; headers?: Record<string, string> },
+    customReqOpts: ICloudbaseUploadFileParams['customReqOpts'],
+  ) => {
+    let res = await request.gateWay(
+      {
+        path: 'storages',
+        name: 'get-objects-upload-info',
+        data: [
+          {
+            objectId: params.path,
+            ...(params.headers ? { signedHeader: params.headers } : {}),
+          },
+        ],
+      },
+      customReqOpts,
+    )
+    const data = res.data?.[0] || {}
+
+    res = {
+      ...res,
+      data: {
+        ...(data.code ? { ...data } : {}),
+        authorization: data.authorization,
+        token: data.token,
+        url: data.uploadUrl,
+        fileId: data.cloudObjectId,
+        cosFileId: data.cloudObjectMeta,
+        download_url: data.downloadUrl,
+      },
+    }
+
+    return res
+  },
+  getDownLoadInfo: async (
+    request,
+    params: { convertedFileList: Array<{ fileid: string }> },
+    customReqOpts: ICloudbaseUploadFileParams['customReqOpts'],
+  ) => {
+    let res = await request.gateWay(
+      {
+        path: 'storages',
+        name: 'get-objects-download-info',
+        data: params.convertedFileList.map((v: any) => ({ cloudObjectId: v.fileid })),
+      },
+      customReqOpts,
+    )
+    res = {
+      ...res,
+      data: {
+        download_list: res.data?.map(v => ({
+          code: v.code || 'SUCCESS',
+          message: v.message,
+          fileid: v.cloudObjectId,
+          download_url: v.downloadUrl,
+          fileID: v.cloudObjectId,
+          tempFileURL: v.downloadUrl,
+        })),
+      },
+    }
+
+    return res
+  },
+  delete: async (
+    request,
+    params: { fileList: Array<string> },
+    customReqOpts: ICloudbaseUploadFileParams['customReqOpts'],
+  ) => {
+    let res = await request.gateWay(
+      {
+        path: 'storages',
+        name: 'delete-objects',
+        data: params.fileList.map(v => ({ cloudObjectId: v })),
+      },
+      customReqOpts,
+    )
+    res = {
+      ...res,
+      data: {
+        delete_list: res.data?.map(v => ({
+          code: v.code || 'SUCCESS',
+          fileID: v.cloudObjectId,
+          message: v.message,
+        })),
+      },
+    }
+
+    return res
+  },
+  copyFile: async (
+    request,
+    params: {
+      convertedFileList: Array<{ src_path: string; dst_path: string; overwrite: boolean; remove_original: boolean }>
+    },
+    customReqOpts: ICloudbaseUploadFileParams['customReqOpts'],
+  ) => {
+    let res = await request.gateWay(
+      {
+        path: 'storages',
+        name: 'copy-objects',
+        data: params.convertedFileList.map((v: any) => ({
+          srcPath: v.src_path,
+          dstPath: v.dst_path,
+          overwrite: v.overwrite,
+          removeOriginal: v.remove_original,
+        })),
+      },
+      customReqOpts,
+    )
+    res = {
+      ...res,
+      data: {
+        copy_list: res.data?.map(v => ({
+          code: v.code || 'SUCCESS',
+          fileID: v.cloudObjectId,
+          message: v.message,
+        })),
+      },
+    }
+
+    return res
+  },
+}
+
+export interface ICloudbaseContext {
+  config: any
+  request: any
+}
+
+export class CloudbaseStorage {
+  public isGateWay() {
+    // @ts-ignore
+    const { config } = this
+    const endPointMode = config.endPointMode || 'CLOUD_API'
+
+    return endPointMode === 'GATEWAY'
+  }
+
+  @catchErrorsDecorator({
+    customInfo: {
+      className: 'Cloudbase',
+      methodName: 'uploadFile',
+    },
+    title: '上传文件失败',
+    messages: [
+      '请确认以下各项：',
+      '  1 - 调用 uploadFile() 的语法或参数是否正确',
+      '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',
+      '  3 - 云存储安全规则是否限制了当前登录状态访问',
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
+  })
+  public async uploadFile(
+    params: Omit<ICloudbaseUploadFileParams, 'filePath'> & { filePath?: string },
+    callback?: Function,
+  ): Promise<ICloudbaseUploadFileResult> {
+    const { cloudPath, filePath, onUploadProgress, method = 'put', headers = {}, fileContent } = params
+    if (!isString(cloudPath) || (!filePath && !fileContent)) {
+      throw new Error(JSON.stringify({
+        code: ERRORS.INVALID_PARAMS,
+        msg: `[${COMPONENT_NAME}.uploadFile] invalid params`,
+      }),)
+    }
+    const uploadMethod =      { put: EUploadMethod.put, post: EUploadMethod.post }[method.toLocaleLowerCase()] || EUploadMethod.put
+
+    // 调用 getUploadMetadata 获取上传元数据
+    const metadataResult = await this.getUploadMetadata({
+      cloudPath,
+      method: uploadMethod,
+      headers: uploadMethod === EUploadMethod.put ? headers : undefined,
+      customReqOpts: params.customReqOpts,
+    })
+
+    const { data: metadata, requestId } = metadataResult
+    const { url, authorization, token, fileId, cosFileId, download_url: downloadUrl } = metadata
+
+    const commonParams = {
+      url,
+      file: filePath,
+      name: cloudPath,
+      onUploadProgress,
+      fileContent,
+      fileId,
+      requestId,
+    }
+
+    const putParams = {
+      ...commonParams,
+      method: EUploadMethod.put,
+      headers: {
+        ...headers,
+        authorization,
+        'x-cos-meta-fileid': cosFileId,
+        'x-cos-security-token': token,
+      },
+    }
+
+    const postParams = {
+      ...commonParams,
+      method: EUploadMethod.post,
+      data: {
+        key: cloudPath,
+        signature: authorization,
+        'x-cos-meta-fileid': cosFileId,
+        success_action_status: '201',
+        'x-cos-security-token': token,
+      },
+    }
+
+    const uploadConfig = {
+      [EUploadMethod.put]: {
+        params: putParams,
+        isSuccess: (code: number) => code >= 200 && code < 300,
+      },
+      [EUploadMethod.post]: {
+        params: postParams,
+        isSuccess: (code: number) => code === 201,
+      },
+    }
+
+    // @ts-ignore
+    const res = await this.request.upload(uploadConfig[uploadMethod].params)
+
+    if (uploadConfig[uploadMethod].isSuccess(res.statusCode)) {
+      return execCallback(callback, null, {
+        fileID: fileId,
+        download_url: downloadUrl,
+        requestId,
+      })
+    }
+    return execCallback(
+      callback,
+      new Error(`[${getSdkName()}][${ERRORS.OPERATION_FAIL}][${COMPONENT_NAME}]:${res.data}`),
+    )
+  }
+  @catchErrorsDecorator({
+    customInfo: {
+      className: 'Cloudbase',
+      methodName: 'getUploadMetadata',
+    },
+    title: '获取上传元信息失败',
+    messages: [
+      '请确认以下各项：',
+      '  1 - 调用 getUploadMetadata() 的语法或参数是否正确',
+      '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',
+      '  3 - 云存储安全规则是否限制了当前登录状态访问',
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
+  })
+  public async getUploadMetadata(
+    params: ICloudbaseGetUploadMetadataParams & {
+      method?: EUploadMethod
+      headers?: Record<string, string>
+    },
+    callback?: Function,
+  ): Promise<{ data: IUploadMetadata; requestId: string }> {
+    const { cloudPath, method, headers } = params
+    if (!isString(cloudPath)) {
+      throw new Error(JSON.stringify({
+        code: ERRORS.INVALID_PARAMS,
+        msg: `[${COMPONENT_NAME}.getUploadMetadata] invalid cloudPath`,
+      }),)
+    }
+    // @ts-ignore
+    const { request } = this
+    const action = 'storage.getUploadMetadata'
+
+    try {
+      let metaData: ICloudbaseFileMetaDataRes
+
+      const metaDataParam: {
+        path: string
+        method?: EUploadMethod
+        headers?: Record<string, string>
+      } = { path: cloudPath }
+
+      if (method) {
+        metaDataParam.method = method
+      }
+      if (method === EUploadMethod.put && headers) {
+        metaDataParam.headers = headers
+      }
+
+      if (this.isGateWay()) {
+        metaData = await storageGateWay.getUploadInfo(request, metaDataParam, params.customReqOpts)
+      } else {
+        metaData = await request.send(action, metaDataParam, params.customReqOpts)
+      }
+      return execCallback(callback, null, metaData)
+    } catch (err) {
+      return execCallback(callback, err)
+    }
+  }
+  @catchErrorsDecorator({
+    customInfo: {
+      className: 'Cloudbase',
+      methodName: 'deleteFile',
+    },
+    title: '删除文件失败',
+    messages: [
+      '请确认以下各项：',
+      '  1 - 调用 deleteFile() 的语法或参数是否正确',
+      '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',
+      '  3 - 云存储安全规则是否限制了当前登录状态访问',
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
+  })
+  public async deleteFile(
+    params: ICloudbaseDeleteFileParams,
+    callback?: Function,
+  ): Promise<ICloudbaseDeleteFileResult> {
+    const { fileList } = params
+
+    if (!fileList || !isArray(fileList) || fileList.length === 0) {
+      throw new Error(JSON.stringify({
+        code: ERRORS.INVALID_PARAMS,
+        msg: `[${COMPONENT_NAME}.deleteFile] fileList must not be empty`,
+      }),)
+    }
+
+    for (const fileId of fileList) {
+      if (!fileId || !isString(fileId)) {
+        throw new Error(JSON.stringify({
+          code: ERRORS.INVALID_PARAMS,
+          msg: `[${COMPONENT_NAME}.deleteFile] fileID must be string`,
+        }),)
+      }
+    }
+
+    const action = 'storage.batchDeleteFile'
+    // @ts-ignore
+    const { request } = this
+    let res: any = {}
+
+    if (this.isGateWay()) {
+      res = await storageGateWay.delete(request, { fileList }, params.customReqOpts)
+    } else {
+      res = await request.send(
+        action,
+        {
+          fileid_list: fileList,
+        },
+        params.customReqOpts,
+      )
+    }
+
+    if (res.code) {
+      return execCallback(callback, null, res)
+    }
+    const data = {
+      fileList: res.data.delete_list,
+      requestId: res.requestId,
+    }
+    return execCallback(callback, null, data)
+  }
+  @catchErrorsDecorator({
+    customInfo: {
+      className: 'Cloudbase',
+      methodName: 'getTempFileURL',
+    },
+    title: '获取文件下载链接',
+    messages: [
+      '请确认以下各项：',
+      '  1 - 调用 getTempFileURL() 的语法或参数是否正确',
+      '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',
+      '  3 - 云存储安全规则是否限制了当前登录状态访问',
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
+  })
+  public async getTempFileURL(
+    params: ICloudbaseGetTempFileURLParams,
+    callback?: Function,
+  ): Promise<ICloudbaseGetTempFileURLResult> {
+    const { fileList } = params
+
+    if (!fileList || !isArray(fileList) || fileList.length === 0) {
+      throw new Error(JSON.stringify({
+        code: ERRORS.INVALID_PARAMS,
+        msg: `[${COMPONENT_NAME}.getTempFileURL] fileList must not be empty`,
+      }),)
+    }
+
+    const convertedFileList = []
+    for (const file of fileList) {
+      if (isPalinObject(file)) {
+        if (!Object.prototype.hasOwnProperty.call(file, 'fileID')) {
+          throw new Error(JSON.stringify({
+            code: ERRORS.INVALID_PARAMS,
+            msg: `[${COMPONENT_NAME}.getTempFileURL] file info must include fileID`,
+          }),)
+        }
+
+        convertedFileList.push({
+          fileid: (file as ICloudbaseFileInfo).fileID,
+          max_age: (file as ICloudbaseFileInfo).maxAge || 7200,
+        })
+      } else if (isString(file)) {
+        convertedFileList.push({
+          fileid: file,
+        })
+      } else {
+        throw new Error(JSON.stringify({
+          code: ERRORS.INVALID_PARAMS,
+          msg: `[${COMPONENT_NAME}.getTempFileURL] invalid fileList`,
+        }),)
+      }
+    }
+
+    const action = 'storage.batchGetDownloadUrl'
+    // @ts-ignore
+    const { request } = this
+    let res: any = {}
+
+    if (this.isGateWay()) {
+      res = await storageGateWay.getDownLoadInfo(request, { convertedFileList }, params.customReqOpts)
+    } else {
+      res = await request.send(action, { file_list: convertedFileList }, params.customReqOpts)
+    }
+
+    if (res.code) {
+      return execCallback(callback, null, res)
+    }
+
+    return execCallback(callback, null, {
+      fileList: res.data.download_list,
+      requestId: res.requestId,
+    })
+  }
+  @catchErrorsDecorator({
+    customInfo: {
+      className: 'Cloudbase',
+      methodName: 'downloadFile',
+    },
+    title: '下载文件失败',
+    messages: [
+      '请确认以下各项：',
+      '  1 - 调用 downloadFile() 的语法或参数是否正确',
+      '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',
+      '  3 - 云存储安全规则是否限制了当前登录状态访问',
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
+  })
+  public async downloadFile(
+    params: ICloudbaseDownloadFileParams,
+    callback?: Function,
+  ): Promise<ICloudbaseDownloadFileResult> {
+    const { fileID } = params
+    if (!isString(fileID)) {
+      throw new Error(JSON.stringify({
+        code: ERRORS.INVALID_PARAMS,
+        msg: `[${COMPONENT_NAME}.getTempFileURL] fileID must be string`,
+      }),)
+    }
+
+    const tmpUrlRes = await this.getTempFileURL.call(this, {
+      fileList: [
+        {
+          fileID,
+          maxAge: 600,
+        },
+      ],
+      customReqOpts: params.customReqOpts,
+    })
+
+    const res = tmpUrlRes.fileList[0]
+
+    if (res.code !== 'SUCCESS') {
+      return execCallback(callback, res)
+    }
+    // @ts-ignore
+    const { request } = this
+
+    const tmpUrl = encodeURI(res.download_url)
+
+    const result = await request.download({ url: tmpUrl, tempFilePath: params.tempFilePath })
+    return execCallback(callback, null, result)
+  }
+  @catchErrorsDecorator({
+    customInfo: {
+      className: 'Cloudbase',
+      methodName: 'copyFile',
+    },
+    title: '批量复制文件',
+    messages: [
+      '请确认以下各项：',
+      '  1 - 调用 copyFile() 的语法或参数是否正确',
+      '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',
+      '  3 - 云存储安全规则是否限制了当前登录状态访问',
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
+  })
+  public async copyFile(params: ICloudbaseCopyFileParams, callback?: Function): Promise<ICloudbaseCopyFileResult> {
+    const { fileList } = params
+
+    if (!fileList || !isArray(fileList) || fileList.length === 0) {
+      throw new Error(JSON.stringify({
+        code: ERRORS.INVALID_PARAMS,
+        msg: `[${COMPONENT_NAME}.copyFile] fileList must not be empty`,
+      }),)
+    }
+
+    const convertedFileList = []
+
+    for (const file of fileList) {
+      const { srcPath, dstPath } = file
+      if (!srcPath || !dstPath || typeof srcPath !== 'string' || typeof dstPath !== 'string') {
+        throw new Error(JSON.stringify({
+          code: ERRORS.INVALID_PARAMS,
+          msg: `[${COMPONENT_NAME}.copyFile] srcPath and dstPath may not be empty`,
+        }),)
+      }
+      if (srcPath === dstPath) {
+        throw new Error(JSON.stringify({
+          code: ERRORS.INVALID_PARAMS,
+          msg: `[${COMPONENT_NAME}.copyFile] srcPath and dstPath can not be the same`,
+        }),)
+      }
+      //   if (basename(srcPath) !== basename(dstPath)) {
+      //     throw new Error(JSON.stringify({
+      //       code: ERRORS.INVALID_PARAMS,
+      //       msg: `[${COMPONENT_NAME}.copyFile] srcPath and dstPath file name must be the same`,
+      //     }),)
+      //   }
+      convertedFileList.push({
+        src_path: srcPath,
+        dst_path: dstPath,
+        overwrite: file.overwrite,
+        remove_original: file.removeOriginal,
+      })
+    }
+
+    // @ts-ignore
+    const { request } = this
+    let res: any = {}
+
+    if (this.isGateWay()) {
+      res = await storageGateWay.copyFile(request, { convertedFileList }, params.customReqOpts)
+    } else {
+      const action = 'storage.batchCopyFile'
+      res = await request.send(action, { file_list: convertedFileList }, params.customReqOpts)
+    }
+
+    if (res.code) {
+      return execCallback(callback, null, res)
+    }
+
+    return execCallback(callback, null, {
+      fileList: res.data.copy_list,
+      requestId: res.requestId,
+    })
+  }
+
+  public async getFileInfo(params: ICloudbaseGetTempFileURLParams): Promise<{
+    fileList: (Pick<ICloudbaseGetTempFileURLResult['fileList'][0], 'code' | 'fileID' | 'tempFileURL' | 'message'> & {
+      fileName?: string
+      cloudId?: ICloudbaseGetTempFileURLResult['fileList'][0]['fileID']
+      contentType?: string
+      mime?: string
+      size?: number
+      cacheControl?: string
+      lastModified?: string
+      etag?: string
+    })[]
+    requestId: string
+  }> {
+    const fileInfo = await this.getTempFileURL(params)
+
+    if (fileInfo?.fileList && fileInfo?.fileList?.length > 0) {
+      const fileList = await Promise.all(fileInfo.fileList.map(async (item: ICloudbaseGetTempFileURLResult['fileList'][0]) => {
+        if (item.code !== 'SUCCESS') {
+          return {
+            code: item.code,
+            fileID: item.fileID,
+            tempFileURL: item.tempFileURL,
+            message: item.message,
+          }
+        }
+
+        try {
+          // @ts-ignore
+          const { request } = this
+          const res = await request.fetch({ url: item.tempFileURL, method: 'HEAD' })
+          let { header } = res
+
+          if (Headers && header instanceof Headers) {
+            header = Object.fromEntries(res.header.entries())
+          }
+          // eslint-disable-next-line radix
+          const fileSize = parseInt(header['content-length']) || 0
+          const contentType = header['content-type'] || ''
+
+          if ([400, 404].includes(Number(res.statusCode))) {
+            return {
+              code: 'FILE_NOT_FOUND',
+              fileID: item.fileID,
+              tempFileURL: item.tempFileURL,
+              message: 'file not found',
+            }
+          }
+
+          const fileInfo = {
+            code: item.code,
+            fileID: item.fileID,
+            tempFileURL: item.tempFileURL,
+            cloudId: item.fileID,
+            fileName: item.fileID.split('/').pop(),
+            contentType,
+            mime: contentType.split(';')[0].trim(),
+            size: fileSize,
+            etag: header.etag || '',
+            lastModified: header['last-modified'] || '',
+            cacheControl: header['cache-control'] || '',
+          }
+
+          return fileInfo
+        } catch (e) {
+          return {
+            code: 'FETCH_FILE_INFO_ERROR',
+            fileID: item.fileID,
+            tempFileURL: item.tempFileURL,
+            message: e.message,
+          }
+        }
+      }),)
+
+      return {
+        fileList,
+        requestId: fileInfo.requestId,
+      }
+    }
+
+    return {
+      fileList: [],
+      requestId: fileInfo.requestId,
+    }
+  }
+}
+
 
 declare const cloudbase: ICloudbase
 
@@ -20,6 +698,744 @@ const component: ICloudbaseComponent = {
   },
 }
 
+export class SupabaseFileAPILikeStorage extends CloudbaseStorage {
+  private shouldThrowOnError = false
+  private bucketId = ''
+  private context: ICloudbaseContext
+
+  constructor(context?: ICloudbaseContext) {
+    super()
+    this.context = context
+  }
+
+  get config() {
+    // @ts-ignore
+    return this.context?.config
+  }
+
+  get request() {
+    // @ts-ignore
+    return this.context?.request
+  }
+
+  throwOnError(): this {
+    this.shouldThrowOnError = true
+    return this
+  }
+
+  from(bucket?: string) {
+    this.bucketId = bucket || ''
+    return this
+  }
+
+  async upload(
+    path: string,
+    fileBody: FileBody,
+    fileOptions?: FileOptions,
+  ): Promise<
+    { data: { id: string; path: string; fullPath: string }; error: null } | { data: null; error: StorageError }
+    > {
+    const options = { upsert: true, ...fileOptions }
+    const { cacheControl, contentType, metadata } = options
+    try {
+      const cloudPath = this._getCloudPath(path)
+      const uploadFileParams: Parameters<CloudbaseStorage['uploadFile']>[0] = {
+        cloudPath,
+        filePath: fileBody as any,
+      }
+
+      if (cacheControl || contentType || metadata) {
+        const headers = {}
+        if (cacheControl) {
+          headers['cache-control'] = cacheControl
+        }
+        if (contentType) {
+          headers['content-type'] = contentType
+        }
+
+        if (metadata) {
+          headers['x-cos-metadata-metadata'] = this.toBase64(JSON.stringify(metadata))
+        }
+
+        uploadFileParams.headers = headers
+      }
+
+      const result = await this.uploadFile(uploadFileParams)
+
+      // IUploadFileRes 没有 code 字段，如果没有 fileID 则表示失败
+      if (!result.fileID) {
+        throw new Error(JSON.stringify({
+          code: ERRORS.OPERATION_FAIL,
+          msg: `[${COMPONENT_NAME}.update] no fileID returned`,
+        }),)
+      }
+
+      return {
+        data: {
+          id: result.fileID,
+          path,
+          fullPath: path,
+        },
+        error: null,
+      }
+    } catch (error: any) {
+      if (this.shouldThrowOnError) throw error
+      if (isStorageError(error)) {
+        return {
+          data: null,
+          error,
+        }
+      }
+      throw error
+    }
+  }
+
+  async uploadToSignedUrl(
+    path: string,
+    _token: string,
+    fileBody: FileBody,
+    fileOptions?: FileOptions,
+  ): Promise<
+    { data: { id: string; path: string; fullPath: string }; error: null } | { data: null; error: StorageError }
+    > {
+    return this.upload(path, fileBody, fileOptions)
+  }
+
+  async createSignedUploadUrl(path: string): Promise<
+  | {
+    data: {
+      signedUrl: string
+      token: string
+      path: string
+      // CloudBase 额外的元数据字段
+      authorization?: string
+      id?: string
+      cosFileId?: string
+      downloadUrl?: string
+    }
+    error: null
+  }
+  | { data: null; error: StorageError }
+  > {
+    try {
+      const cloudPath = this._getCloudPath(path)
+
+      const { data: metadata } = await this.getUploadMetadata({ cloudPath })
+
+      return {
+        data: {
+          signedUrl: metadata.url,
+          token: metadata.token,
+          path,
+          // 返回 CloudBase 的额外元数据，供 uploadToSignedUrl 使用
+          authorization: metadata.authorization,
+          id: metadata.fileId,
+          cosFileId: metadata.cosFileId,
+          downloadUrl: metadata.download_url,
+        },
+        error: null,
+      }
+    } catch (error: any) {
+      if (this.shouldThrowOnError) throw error
+      return {
+        data: null,
+        error: error instanceof StorageError ? error : new StorageError(error.message),
+      }
+    }
+  }
+
+  async update(
+    path: string,
+    fileBody: FileBody,
+    fileOptions?: FileOptions,
+  ): Promise<
+    { data: { id: string; path: string; fullPath: string }; error: null } | { data: null; error: StorageError }
+    > {
+    return this.upload(path, fileBody, { ...fileOptions, upsert: true })
+  }
+
+  async move(
+    fromPath: string,
+    toPath: string,
+    // options?: DestinationOptions,
+  ): Promise<{ data: { message: string }; error: null } | { data: null; error: StorageError }> {
+    try {
+      const result = await this.copyFile({
+        fileList: [
+          {
+            srcPath: this._getCloudPath(fromPath),
+            dstPath: this._getCloudPath(toPath),
+            overwrite: true,
+            removeOriginal: true,
+          },
+        ],
+      })
+
+      if (result.fileList[0].code && result.fileList[0].code !== 'SUCCESS') {
+        throw new StorageError(result.fileList[0].message || 'Move failed')
+      }
+
+      return {
+        data: { message: `File moved from ${fromPath} to ${toPath}` },
+        error: null,
+      }
+    } catch (error: any) {
+      if (this.shouldThrowOnError) throw error
+      if (isStorageError(error)) {
+        return {
+          data: null,
+          error,
+        }
+      }
+      throw error
+    }
+  }
+
+  async copy(
+    fromPath: string,
+    toPath: string,
+    // options?: DestinationOptions,
+  ): Promise<{ data: { path: string }; error: null } | { data: null; error: StorageError }> {
+    try {
+      const result = await this.copyFile({
+        fileList: [
+          {
+            srcPath: this._getCloudPath(fromPath),
+            dstPath: this._getCloudPath(toPath),
+            overwrite: true,
+            removeOriginal: false,
+          },
+        ],
+      })
+
+      if (result.fileList[0].code && result.fileList[0].code !== 'SUCCESS') {
+        throw new StorageError(result.fileList[0].message || 'Copy failed')
+      }
+
+      return {
+        data: { path: this._getCloudPath(toPath) },
+        error: null,
+      }
+    } catch (error: any) {
+      if (this.shouldThrowOnError) throw error
+      if (isStorageError(error)) {
+        return { data: null, error }
+      }
+      throw error
+    }
+  }
+
+  async createSignedUrl(
+    path: string,
+    expiresIn: number,
+    options?: {
+      download?: string | boolean
+      transform?: TransformOptions
+    },
+  ): Promise<{ data: { signedUrl: string }; error: null } | { data: null; error: StorageError }> {
+    try {
+      const cloudPath = this._normalizeCloudId(path)
+      const result = await this.getTempFileURL({
+        fileList: [
+          {
+            fileID: cloudPath,
+            maxAge: expiresIn,
+          },
+        ],
+      })
+
+      // IGetFileUrlItem 有 code 字段但没有 message 字段
+      if (result.fileList[0].code !== 'SUCCESS') {
+        throw new StorageError(`Failed to create signed URL: [${result.fileList[0].code}] ${result.fileList[0].fileID}`)
+      }
+
+      let signedUrl = result.fileList[0].download_url
+
+      // 构建查询参数
+      const queryParams: string[] = []
+
+      // 如果有 download 参数，添加到 URL 中
+      if (options?.download !== undefined) {
+        if (typeof options.download === 'string') {
+          // download 是文件名
+          queryParams.push(`download=${encodeURIComponent(options.download)}`)
+        } else if (options.download === true) {
+          // download 是 true，使用原文件名或默认值
+          queryParams.push('download=true')
+        }
+      }
+
+      // 如果有图片转换参数，添加到 URL 中
+      if (options?.transform) {
+        const transformQuery = this._transformOptsToQueryString(options.transform)
+        if (transformQuery) {
+          queryParams.push(transformQuery)
+        }
+      }
+
+      // 拼接所有查询参数
+      if (queryParams.length > 0) {
+        const separator = signedUrl.includes('?') ? '&' : '?'
+        signedUrl = `${signedUrl}${separator}${queryParams.join('&')}`
+      }
+
+      return {
+        data: { signedUrl },
+        error: null,
+      }
+    } catch (error: any) {
+      if (this.shouldThrowOnError) throw error
+      if (isStorageError(error)) {
+        return {
+          data: null,
+          error,
+        }
+      }
+      throw error
+    }
+  }
+
+  async createSignedUrls(
+    paths: string[],
+    expiresIn: number,
+    // options?: {
+    //   download?: string | boolean
+    // },
+  ): Promise<
+    | { data: Array<{ path: string; signedUrl: string; error: string | null }>; error: null }
+    | { data: null; error: StorageError }
+    > {
+    try {
+      const fileList = paths.map(p => ({
+        fileID: this._normalizeCloudId(p),
+        maxAge: expiresIn,
+      }))
+
+      const result = await this.getTempFileURL({ fileList })
+
+      return {
+        data: result.fileList.map((item: any, index: number) => ({
+          path: paths[index],
+          signedUrl: item.tempFileURL || '',
+          error: item.code === 'SUCCESS' ? null : item.message,
+        })),
+        error: null,
+      }
+    } catch (error: any) {
+      if (this.shouldThrowOnError) throw error
+      if (isStorageError(error)) {
+        return {
+          data: null,
+          error,
+        }
+      }
+      throw error
+    }
+  }
+
+  async download(
+    path: string,
+    options?: TransformOptions,
+  ): Promise<{
+      data: Blob
+      error: StorageError | null
+    }> {
+    try {
+      return {
+        data: await (async () => {
+          const signedUrlResult = await this.createSignedUrl(path, 600, { transform: options })
+          if (signedUrlResult.error) {
+            throw signedUrlResult.error
+          }
+          const tmpUrl = encodeURI(signedUrlResult.data?.signedUrl)
+
+          const { data } = await (this as any).request.reqClass.get({
+            url: tmpUrl,
+            headers: {}, // 下载资源请求不经过service，header清空
+            responseType: 'blob',
+          })
+
+          if (!data) {
+            throw new StorageError('Download failed: no file content')
+          }
+
+          // 将 Buffer 转换为 Uint8Array 以兼容 Blob
+          return new Blob([data])
+        })(),
+        error: null,
+      }
+    } catch (error: any) {
+      if (this.shouldThrowOnError) throw error
+      if (isStorageError(error)) {
+        return {
+          data: null,
+          error,
+        }
+      }
+      throw error
+    }
+  }
+
+  /**
+   * 获取文件信息
+   *
+   * @param pathOrFileId - 相对路径（如 'images/photo.jpg'）或 CloudBase fileID（以 'cloud://' 开头）
+   * @returns 文件信息对象
+   *
+   * @example
+   * ```typescript
+   * // 使用相对路径
+   * const { data } = await bucket.info('images/photo.jpg')
+   *
+   * // 使用 CloudBase fileID
+   * const { data } = await bucket.info('cloud://env-id.xxxx-xxxx/images/photo.jpg')
+   * ```
+   */
+  async info(pathOrFileId: string,): Promise<{ data: Camelize<FileObjectV2>; error: null } | { data: null; error: StorageError }> {
+    try {
+      // 判断是 fileID 还是相对路径
+      const isFileId = pathOrFileId.startsWith('cloud://')
+      const displayName = isFileId ? this._extractPathFromFileId(pathOrFileId) : pathOrFileId
+      const bucketId = isFileId ? this._extractBucketFromFileId(pathOrFileId) : this.bucketId
+
+      const fileInfo = await this.getFileInfo({
+        fileList: [this._normalizeCloudId(pathOrFileId)],
+      })
+
+      const item = fileInfo.fileList[0]
+
+      if (item.code !== 'SUCCESS') {
+        throw new StorageError(item.message)
+      }
+
+      const now = new Date().toISOString()
+      const lastModified = (item.lastModified ? new Date(item.lastModified) : new Date()).toISOString()
+      return {
+        data: {
+          id: item.fileID,
+          version: '1',
+          name: displayName,
+          bucketId,
+          updatedAt: lastModified,
+          createdAt: lastModified,
+          lastAccessedAt: now,
+          size: item.size,
+          cacheControl: item.cacheControl,
+          contentType: item.contentType,
+          etag: item.etag,
+          lastModified,
+          metadata: {},
+        },
+        error: null,
+      }
+    } catch (error: any) {
+      if (this.shouldThrowOnError) throw error
+      return {
+        data: null,
+        error: error instanceof StorageError ? error : new StorageError(error.message),
+      }
+    }
+  }
+
+  async exists(pathOrFileId: string): Promise<{ data: boolean; error: null } | { data: null; error: StorageError }> {
+    try {
+      // 判断是 fileID 还是相对路径
+      const fileInfo = await this.getFileInfo({
+        fileList: [this._normalizeCloudId(pathOrFileId)],
+      })
+
+      const item = fileInfo.fileList[0]
+
+      if (item.code === 'FILE_NOT_FOUND') {
+        return {
+          data: false,
+          error: null,
+        }
+      }
+
+      if (item.code !== 'SUCCESS') {
+        throw new StorageError(item.message)
+      }
+
+      return { data: true, error: null }
+    } catch (error: any) {
+      if (this.shouldThrowOnError) throw error
+      throw error
+    }
+  }
+
+  async getPublicUrl(
+    path: string,
+    options?: {
+      download?: string | boolean
+      transform?: TransformOptions
+    },
+  ): Promise<
+    | {
+      data: { publicUrl: string }
+    }
+    | { data: null; error: StorageError }
+    > {
+    const res = await this.createSignedUrl(path, 600, options)
+
+    if (res.data) {
+      return {
+        data: { publicUrl: res.data.signedUrl },
+      }
+    }
+
+    return { data: null, error: res.error as StorageError }
+  }
+
+  async remove(paths: string[]): Promise<{ data: FileObject[]; error: null } | { data: null; error: StorageError }> {
+    try {
+      // 分组获取文件信息，每组最多10个
+      const chunkSize = 10
+      const pathChunks: string[][] = []
+      for (let i = 0; i < paths.length; i += chunkSize) {
+        pathChunks.push(paths.slice(i, i + chunkSize))
+      }
+
+      // 并行获取所有分组的文件信息
+      const fileInfoResults = await Promise.all(pathChunks.map(chunk => Promise.all(chunk.map(path => this.info(path)))),)
+
+      // 合并所有文件信息并构建映射表（path -> fileInfo）
+      const fileInfoMap = new Map<string, Camelize<FileObjectV2>>()
+      fileInfoResults.flat().forEach((result, index) => {
+        if (result.data) {
+          fileInfoMap.set(paths[Math.floor(index / chunkSize) * chunkSize + (index % chunkSize)], result.data)
+        }
+      })
+
+      // 执行删除操作
+      const fileList = paths.map(p => this._normalizeCloudId(p))
+      const result = await this.deleteFile({ fileList })
+
+      // IDeleteFileRes 的 fileList 数组中每个项有 code 字段
+      const failedFiles = result.fileList.filter(item => item.code !== 'SUCCESS')
+      if (failedFiles.length > 0) {
+        throw new StorageError(`Delete failed for ${failedFiles.length} file(s)`)
+      }
+
+      const now = new Date().toISOString()
+
+      // 使用获取到的文件信息构建返回数据
+      return {
+        data: paths.map((p) => {
+          const info = fileInfoMap.get(p)
+
+          return {
+            name: info?.name,
+            id: info?.id,
+            bucket_id: info?.bucketId,
+            owner: undefined, // 无法计算owner
+            updated_at: info?.updatedAt || now,
+            created_at: info?.createdAt,
+            last_accessed_at: info?.lastAccessedAt || now,
+            metadata: info?.metadata || {},
+            /**
+             * TODO: 获取补全 Bucket 信息
+             */
+            buckets: {
+              id: info?.bucketId,
+              name: info?.bucketId,
+              owner: undefined, // 无法计算owner
+              public: false, // 未知
+              created_at: '', // 未知
+              updated_at: now, // 未知
+            },
+          }
+        }),
+        error: null,
+      }
+    } catch (error: any) {
+      if (this.shouldThrowOnError) throw error
+      if (isStorageError(error)) {
+        return {
+          data: null,
+          error,
+        }
+      }
+      throw error
+    }
+  }
+
+  async list() {
+    throw new StorageError('Not implemented')
+  }
+
+  private _getCloudPath(path: string): string {
+    // 清理路径：移除首尾斜杠，合并多个斜杠
+    const cleanPath = path.replace(/^\/|\/$/g, '').replace(/\/+/g, '/')
+
+    // 否则返回清理后的相对路径
+    return cleanPath
+  }
+
+  private _normalizeCloudId(path: string) {
+    // 如果已经是 cloud:// 格式，直接返回
+    if (/^cloud:\/\//.test(path)) {
+      return path
+    }
+    const cleanPath = this._getCloudPath(path)
+
+    // 如果设置了 bucketId，构建完整的 cloud:// 路径
+    if (this.bucketId) {
+      // 获取环境 ID
+      const envId = this.config?.env || ''
+      if (envId) {
+        return `cloud://${envId}.${this.bucketId}/${cleanPath}`
+      }
+    } else {
+      throw new StorageError('bucketId is not set')
+    }
+  }
+
+  private toBase64(data: string) {
+    if (typeof Buffer !== 'undefined') {
+      return Buffer.from(data).toString('base64')
+    }
+    return btoa(data)
+  }
+
+  /**
+   * 将 TransformOptions 转换为腾讯云数据万象的 imageMogr2 查询字符串
+   *
+   * 腾讯云数据万象使用 imageMogr2 接口进行图片处理，支持以下参数：
+   * - /thumbnail/<Width>x<Height> - 缩放
+   * - /format/<Format> - 格式转换
+   * - /quality/<Quality> - 质量调整
+   * - /rquality/<Quality> - 相对质量
+   *
+   * @param transform - Supabase TransformOptions
+   * @returns 腾讯云数据万象的查询字符串
+   *
+   * @example
+   * ```typescript
+   * _transformOptsToQueryString({ width: 300, height: 200, quality: 80, format: 'origin' })
+   * // 返回: 'imageMogr2/thumbnail/300x200/quality/80'
+   * ```
+   */
+  private _transformOptsToQueryString(transform: TransformOptions): string {
+    const params: string[] = ['imageMogr2']
+
+    // 处理缩放参数
+    if (transform.width || transform.height) {
+      const width = transform.width || ''
+      const height = transform.height || ''
+
+      // 根据 resize 模式选择不同的缩放方式
+      if (transform.resize === 'fill') {
+        // fill: 强制缩放到指定尺寸，可能变形
+        params.push(`thumbnail/${width}x${height}!`)
+      } else if (transform.resize === 'contain') {
+        // contain: 等比缩放，完整显示在指定尺寸内
+        params.push(`thumbnail/${width}x${height}`)
+      } else {
+        // cover (默认): 等比缩放，填充指定尺寸，可能裁剪
+        // 使用 /thumbnail/<Width>x<Height>^ 表示填充模式
+        params.push(`thumbnail/${width}x${height}^`)
+      }
+    }
+
+    // 处理格式转换
+    // format: 'origin' 表示保持原格式，不传此参数
+    if (transform.format && transform.format !== 'origin') {
+      params.push(`format/${transform.format}`)
+    }
+
+    // 处理质量参数
+    if (transform.quality !== undefined) {
+      // 腾讯云数据万象的 quality 参数范围是 1-100
+      const quality = Math.max(1, Math.min(100, transform.quality))
+      params.push(`quality/${quality}`)
+    }
+
+    return params.join('/')
+  }
+
+  /**
+   * 从 CloudBase fileID 中提取文件路径
+   *
+   * @param fileId - CloudBase fileID (格式: cloud://env-id.bucket/path/to/file.jpg)
+   * @returns 提取的文件路径
+   *
+   * @example
+   * ```typescript
+   * _extractPathFromFileId('cloud://test-env.test-bucket/images/photo.jpg')
+   * // 返回: 'images/photo.jpg'
+   *
+   * _extractPathFromFileId('cloud://test-env.test-bucket/file.txt')
+   * // 返回: 'file.txt'
+   * ```
+   */
+  private _extractPathFromFileId(fileId: string): string {
+    // fileID 格式: cloud://env-id.bucket/path/to/file.jpg
+    // 需要提取第一个 / 后面的所有内容（包括 bucket 和路径）
+    // 然后再提取 bucket 后面的路径部分
+
+    // 移除 cloud:// 前缀
+    const withoutProtocol = fileId.replace(/^cloud:\/\//, '')
+
+    // 分割为 [env-id.bucket, path, to, file.jpg]
+    const parts = withoutProtocol.split('/')
+
+    if (parts.length < 2) {
+      // 如果无法解析，返回完整的 fileID
+      return fileId
+    }
+
+    // 移除第一部分（env-id.bucket），返回剩余路径
+    return parts.slice(1).join('/')
+  }
+
+  /**
+   * 从 CloudBase fileID 中提取 bucket 名称
+   *
+   * @param fileId - CloudBase fileID (格式: cloud://env-id.bucket/path/to/file.jpg)
+   * @returns 提取的 bucket 名称
+   *
+   * @example
+   * ```typescript
+   * _extractBucketFromFileId('cloud://test-env.test-bucket/images/photo.jpg')
+   * // 返回: 'test-bucket'
+   *
+   * _extractBucketFromFileId('cloud://prod-env.my-bucket/file.txt')
+   * // 返回: 'my-bucket'
+   * ```
+   */
+  private _extractBucketFromFileId(fileId: string): string {
+    // fileID 格式: cloud://env-id.bucket/path/to/file.jpg
+    // 需要提取 env-id.bucket 中的 bucket 部分
+
+    // 移除 cloud:// 前缀
+    const withoutProtocol = fileId.replace(/^cloud:\/\//, '')
+
+    // 分割为 [env-id.bucket, path, to, file.jpg]
+    const parts = withoutProtocol.split('/')
+
+    if (parts.length < 1) {
+      // 如果无法解析，返回默认 bucket
+      return ''
+    }
+
+    // 第一部分是 env-id.bucket，提取 bucket 部分
+    // 格式: env-id.bucket 或 env-id.bucket-name
+    const envAndBucket = parts[0]
+
+    // 查找第一个点的位置
+    const dotIndex = envAndBucket.indexOf('.')
+
+    if (dotIndex === -1) {
+      // 如果没有点，返回整个字符串
+      return envAndBucket
+    }
+
+    // 返回点后面的部分（bucket 名称）
+    return envAndBucket.substring(dotIndex + 1)
+  }
+}
+
 const supabaseComponent: ICloudbaseComponent = {
   name: `${COMPONENT_NAME}/supabase`,
   IIFE: true,