@autonomys/auto-drive 1.2.7 → 1.3.0

package/src/api/wrappers.ts

@@ -3,21 +3,17 @@ import { asyncByChunk, asyncFromStream, bufferToIterable, fileToIterable } from
 import { progressToPercentage } from '../utils/misc'
 import { publicDownloadUrl } from './calls/download'
 import { apiCalls } from './calls/index'
-import { AutoDriveApi } from './connection'
+import { ObjectSummary, Scope } from './models'
+import { PaginatedResult } from './models/common'
 import { GenericFile, GenericFileWithinFolder } from './models/file'
 import { constructFromInput, constructZipBlobFromTreeAndPaths } from './models/folderTree'
 import { SubscriptionInfo } from './models/user'
-
-export type UploadFileOptions = {
-  password?: string
-  compression?: boolean
-  onProgress?: (progress: number) => void
-}
+import { AutoDriveApi, AutoDriveApiHandler, UploadFileOptions } from './types'
 
 const UPLOAD_FILE_CHUNK_SIZE = 1024 * 1024
 
 const uploadFileChunks = (
-  api: AutoDriveApi,
+  api: AutoDriveApiHandler,
   fileUploadId: string,
   asyncIterable: AsyncIterable<Buffer>,
   uploadChunkSize: number = UPLOAD_FILE_CHUNK_SIZE,
@@ -41,35 +37,72 @@ const uploadFileChunks = (
   })
 }
 
-/**
- * Uploads a file to the server with optional encryption and compression.
- *
- * This function reads a file from the provided input, optionally encrypts it
- * using the specified password, and compresses it using the specified algorithm if requested.
- * It uploads the file in chunks to the server, creating an upload session and
- * completing it once all chunks have been successfully uploaded.
- *
- * @param {AutoDriveApi} api - The API instance used to send requests.
- * @param {File} file - The file to be uploaded.
- * @param {UploadFileOptions} options - Options for the upload process.
- * @param {string} [options.password] - The password for encryption (optional).
- * @param {boolean} [options.compression=true] - Whether to compress the file (optional).
- * @param {number} [uploadChunkSize] - The size of each chunk to upload (optional).
- * @returns {PromisedObservable<UploadFileStatus>} - An observable that emits the upload status.
- * @throws {Error} - Throws an error if the upload fails at any stage.
- */
-export const uploadFileFromInput = (
-  api: AutoDriveApi,
-  file: File,
-  options: UploadFileOptions = {},
-  uploadChunkSize?: number,
-): Promise<string> => {
-  const { password = undefined, compression = true } = options
-  return new Promise(async (resolve, reject) => {
+export const createApiInterface = (api: AutoDriveApiHandler): AutoDriveApi => {
+  const uploadFileFromInput = (
+    file: File,
+    options: UploadFileOptions = {},
+    uploadChunkSize?: number,
+  ): Promise<string> => {
+    const { password = undefined, compression = true } = options
+    return new Promise(async (resolve, reject) => {
+      const { compressFile, CompressionAlgorithm, encryptFile, EncryptionAlgorithm } = await import(
+        '@autonomys/auto-dag-data'
+      )
+      let asyncIterable: AsyncIterable<Buffer> = fileToIterable(file)
+
+      if (compression) {
+        asyncIterable = compressFile(asyncIterable, {
+          level: 9,
+          algorithm: CompressionAlgorithm.ZLIB,
+        })
+      }
+
+      if (password) {
+        asyncIterable = encryptFile(asyncIterable, password, {
+          algorithm: EncryptionAlgorithm.AES_256_GCM,
+        })
+      }
+
+      const uploadOptions = {
+        compression: compression
+          ? {
+              level: 9,
+              algorithm: CompressionAlgorithm.ZLIB,
+            }
+          : undefined,
+        encryption: password
+          ? {
+              algorithm: EncryptionAlgorithm.AES_256_GCM,
+            }
+          : undefined,
+      }
+      const fileUpload = await apiCalls.createFileUpload(api, {
+        mimeType: mime.lookup(file.name) || undefined,
+        filename: file.name,
+        uploadOptions,
+      })
+
+      await uploadFileChunks(api, fileUpload.id, asyncIterable, uploadChunkSize, (bytes) => {
+        options.onProgress?.(progressToPercentage(bytes, file.size))
+      })
+
+      const result = await apiCalls.completeUpload(api, { uploadId: fileUpload.id })
+
+      resolve(result.cid)
+    })
+  }
+
+  const uploadFile = async (
+    file: GenericFile,
+    options: UploadFileOptions = {},
+    uploadChunkSize?: number,
+  ): Promise<string> => {
+    const { password = undefined, compression = true } = options
+
     const { compressFile, CompressionAlgorithm, encryptFile, EncryptionAlgorithm } = await import(
       '@autonomys/auto-dag-data'
     )
-    let asyncIterable: AsyncIterable<Buffer> = fileToIterable(file)
+    let asyncIterable: AsyncIterable<Buffer> = file.read()
 
     if (compression) {
       asyncIterable = compressFile(asyncIterable, {
@@ -109,302 +142,216 @@ export const uploadFileFromInput = (
 
     const result = await apiCalls.completeUpload(api, { uploadId: fileUpload.id })
 
-    resolve(result.cid)
-  })
-}
+    return result.cid
+  }
 
-/**
- * Uploads a file to the server with optional encryption and compression.
- *
- * This function reads a file from the provided input, optionally encrypts it
- * using the specified password, and compresses it using the specified algorithm if requested.
- * It uploads the file in chunks to the server, creating an upload session and
- * completing it once all chunks have been successfully uploaded.
- *
- * @param {AutoDriveApi} api - The API instance used to send requests.
- * @param {File | GenericFile} file - The file to be uploaded, which can be a File or a GenericFile.
- * @param {UploadFileOptions} options - Options for the upload process.
- * @param {string} [options.password] - The password for encryption (optional).
- * @param {boolean} [options.compression=true] - Whether to compress the file (optional).
- * @param {number} [uploadChunkSize] - The size of each chunk to upload (optional).
- * @returns {Promise<string>} - The CID of the uploaded file.
- * @throws {Error} - Throws an error if the upload fails at any stage.
- */
-export const uploadFile = async (
-  api: AutoDriveApi,
-  file: GenericFile,
-  options: UploadFileOptions = {},
-  uploadChunkSize?: number,
-): Promise<string> => {
-  const { password = undefined, compression = true } = options
-
-  const { compressFile, CompressionAlgorithm, encryptFile, EncryptionAlgorithm } = await import(
-    '@autonomys/auto-dag-data'
-  )
-  let asyncIterable: AsyncIterable<Buffer> = file.read()
-
-  if (compression) {
-    asyncIterable = compressFile(asyncIterable, {
-      level: 9,
-      algorithm: CompressionAlgorithm.ZLIB,
-    })
+  const uploadObjectAsJSON = async (
+    object: unknown,
+    name?: string | undefined,
+    options: UploadFileOptions = {},
+    uploadChunkSize?: number,
+  ): Promise<string> => {
+    try {
+      const json = Buffer.from(JSON.stringify(object))
+      return uploadFile(
+        {
+          read: () => bufferToIterable(json),
+          name: name || 'object.json',
+          mimeType: 'application/json',
+          size: json.length,
+        },
+        options,
+        uploadChunkSize,
+      )
+    } catch (e) {
+      throw new Error('Failed to serialize object to JSON')
+    }
   }
 
-  if (password) {
-    asyncIterable = encryptFile(asyncIterable, password, {
-      algorithm: EncryptionAlgorithm.AES_256_GCM,
+  const uploadFolderFromInput = async (
+    fileList: FileList | File[],
+    {
+      uploadChunkSize,
+      password,
+      onProgress,
+    }: {
+      uploadChunkSize?: number
+      password?: string
+      onProgress?: (progress: number) => void
+    } = {},
+  ): Promise<string> => {
+    const files = fileList instanceof FileList ? Array.from(fileList) : fileList
+    const fileTree = constructFromInput(files)
+
+    // If password is provided, we zip the files and upload the zip file
+    if (password) {
+      const filesMap: Record<string, File> = Object.fromEntries(
+        files.map((file) => [file.webkitRelativePath, file]),
+      )
+      const zipBlob = await constructZipBlobFromTreeAndPaths(fileTree, filesMap)
+      const name = fileList[0].webkitRelativePath.split('/').filter(Boolean)[0]!
+
+      return uploadFile(
+        {
+          read: () => fileToIterable(zipBlob),
+          name: `${name}.zip`,
+          mimeType: 'application/zip',
+          size: zipBlob.size,
+        },
+        {
+          password,
+          compression: true,
+          onProgress,
+        },
+      )
+    }
+
+    // Otherwise, we upload the files as a folder w/o compression or encryption
+    const folderUpload = await apiCalls.createFolderUpload(api, {
+      fileTree,
     })
-  }
 
-  const uploadOptions = {
-    compression: compression
-      ? {
-          level: 9,
-          algorithm: CompressionAlgorithm.ZLIB,
-        }
-      : undefined,
-    encryption: password
-      ? {
-          algorithm: EncryptionAlgorithm.AES_256_GCM,
-        }
-      : undefined,
+    let currentBytesUploaded = 0
+    const totalSize = files.reduce((acc, file) => acc + file.size, 0)
+    for (const file of files) {
+      await uploadFileWithinFolderUpload(
+        folderUpload.id,
+        {
+          read: () => fileToIterable(file),
+          name: file.name,
+          mimeType: mime.lookup(file.name) || undefined,
+          size: file.size,
+          path: file.webkitRelativePath,
+        },
+        uploadChunkSize,
+        {
+          onProgress: (progress) => {
+            onProgress?.(progressToPercentage(currentBytesUploaded + progress, totalSize))
+          },
+        },
+      )
+      currentBytesUploaded += file.size
+    }
+
+    const result = await apiCalls.completeUpload(api, { uploadId: folderUpload.id })
+
+    return result.cid
   }
-  const fileUpload = await apiCalls.createFileUpload(api, {
-    mimeType: mime.lookup(file.name) || undefined,
-    filename: file.name,
-    uploadOptions,
-  })
 
-  await uploadFileChunks(api, fileUpload.id, asyncIterable, uploadChunkSize, (bytes) => {
-    options.onProgress?.(progressToPercentage(bytes, file.size))
-  })
+  const uploadFileWithinFolderUpload = async (
+    uploadId: string,
+    file: GenericFileWithinFolder,
+    uploadChunkSize?: number,
+    options: Pick<UploadFileOptions, 'onProgress'> = {},
+  ): Promise<string> => {
+    const fileUpload = await apiCalls.createFileUploadWithinFolderUpload(api, {
+      uploadId,
+      name: file.name,
+      mimeType: file.mimeType,
+      relativeId: file.path,
+      uploadOptions: {},
+    })
 
-  const result = await apiCalls.completeUpload(api, { uploadId: fileUpload.id })
+    await uploadFileChunks(api, fileUpload.id, file.read(), uploadChunkSize, options.onProgress)
 
-  return result.cid
-}
+    const result = await apiCalls.completeUpload(api, { uploadId: fileUpload.id })
 
-/**
- * Uploads an object as a JSON file to the server.
- *
- * This function serializes the provided object to a JSON string,
- * and then uploads the JSON string as a file to the server.
- *
- * @param {AutoDriveApi} api - The API instance used to send requests.
- * @param {File | GenericFile} file - The file to be uploaded, which can be a File or a GenericFile.
- * @param {UploadFileOptions} options - Options for the upload process.
- * @param {string} [options.password] - The password for encryption (optional).
- * @param {boolean} [options.compression=true] - Whether to compress the file (optional).
- * @param {number} [uploadChunkSize] - The size of each chunk to upload (optional).
- * @returns {Promise<string>} - The CID of the uploaded file.
- * @throws {Error} - Throws an error if the upload fails at any stage.
- */
-export const uploadObjectAsJSON = async (
-  api: AutoDriveApi,
-  object: unknown,
-  name?: string | undefined,
-  options: UploadFileOptions = {},
-  uploadChunkSize?: number,
-): Promise<string> => {
-  try {
-    const json = Buffer.from(JSON.stringify(object))
-    return uploadFile(
-      api,
-      {
-        read: () => bufferToIterable(json),
-        name: name || 'object.json',
-        mimeType: 'application/json',
-        size: json.length,
-      },
-      options,
-      uploadChunkSize,
-    )
-  } catch (e) {
-    throw new Error('Failed to serialize object to JSON')
+    return result.cid
   }
-}
 
-/**
- * Uploads an entire folder to the server.
- *
- * This function retrieves all files within the specified folder,
- * constructs a file tree representation, and initiates the upload
- * process. It also handles optional compression of the files during
- * the upload. If a password is provided, the files will be zipped
- * before uploading.
- *
- * @param {AutoDriveApi} api - The API instance used to send requests.
- * @param {FileList | File[]} fileList - The list of files to be uploaded.
- * @param {Object} options - Options for the upload process.
- * @param {number} [options.uploadChunkSize] - The size of each chunk to upload (optional).
- * @param {string} [options.password] - The password for encryption (optional).
- * @returns {PromisedObservable<UploadFileStatus | UploadFolderStatus>} - An observable that emits the upload status.
- * @throws {Error} - Throws an error if the upload fails at any stage.
- */
-export const uploadFolderFromInput = async (
-  api: AutoDriveApi,
-  fileList: FileList | File[],
-  {
-    uploadChunkSize,
-    password,
-    onProgress,
-  }: { uploadChunkSize?: number; password?: string; onProgress?: (progress: number) => void } = {},
-): Promise<string> => {
-  const files = fileList instanceof FileList ? Array.from(fileList) : fileList
-  const fileTree = constructFromInput(files)
-
-  // If password is provided, we zip the files and upload the zip file
-  if (password) {
-    const filesMap: Record<string, File> = Object.fromEntries(
-      files.map((file) => [file.webkitRelativePath, file]),
-    )
-    const zipBlob = await constructZipBlobFromTreeAndPaths(fileTree, filesMap)
-    const name = fileList[0].webkitRelativePath.split('/').filter(Boolean)[0]!
-
-    return uploadFile(
-      api,
-      {
-        read: () => fileToIterable(zipBlob),
-        name: `${name}.zip`,
-        mimeType: 'application/zip',
-        size: zipBlob.size,
-      },
-      {
-        password,
-        compression: true,
-        onProgress,
-      },
+  const downloadFile = async (cid: string, password?: string): Promise<AsyncIterable<Buffer>> => {
+    const { decompressFile, CompressionAlgorithm, EncryptionAlgorithm, decryptFile } = await import(
+      '@autonomys/auto-dag-data'
     )
-  }
 
-  // Otherwise, we upload the files as a folder w/o compression or encryption
-  const folderUpload = await apiCalls.createFolderUpload(api, {
-    fileTree,
-  })
+    const metadata = await apiCalls.getObjectMetadata(api, { cid })
 
-  let currentBytesUploaded = 0
-  const totalSize = files.reduce((acc, file) => acc + file.size, 0)
-  for (const file of files) {
-    await uploadFileWithinFolderUpload(
-      api,
-      folderUpload.id,
-      {
-        read: () => fileToIterable(file),
-        name: file.name,
-        mimeType: mime.lookup(file.name) || undefined,
-        size: file.size,
-        path: file.webkitRelativePath,
-      },
-      uploadChunkSize,
-      {
-        onProgress: (progress) => {
-          onProgress?.(progressToPercentage(currentBytesUploaded + progress, totalSize))
-        },
-      },
-    )
-    currentBytesUploaded += file.size
-  }
+    let iterable = asyncFromStream(await apiCalls.downloadObject(api, { cid }))
+    if (metadata.uploadOptions?.encryption) {
+      if (!password) {
+        throw new Error('Password is required to decrypt the file')
+      }
+      iterable = decryptFile(iterable, password, {
+        algorithm: EncryptionAlgorithm.AES_256_GCM,
+      })
+    }
 
-  const result = await apiCalls.completeUpload(api, { uploadId: folderUpload.id })
+    if (metadata.uploadOptions?.compression) {
+      iterable = decompressFile(iterable, {
+        algorithm: CompressionAlgorithm.ZLIB,
+      })
+    }
 
-  return result.cid
-}
+    return iterable
+  }
 
-/**
- * Uploads a file within an existing folder upload session.
- *
- * @param {AutoDriveApi} api - The API instance to interact with the AutoDrive service.
- * @param {string} uploadId - The ID of the folder upload session to which the file will be added.
- * @param {string} filepath - The path of the file to be uploaded.
- *
- * @returns {Promise<void>} A promise that resolves when the file upload is complete.
- */
-export const uploadFileWithinFolderUpload = async (
-  api: AutoDriveApi,
-  uploadId: string,
-  file: GenericFileWithinFolder,
-  uploadChunkSize?: number,
-  options: Pick<UploadFileOptions, 'onProgress'> = {},
-): Promise<string> => {
-  const fileUpload = await apiCalls.createFileUploadWithinFolderUpload(api, {
-    uploadId,
-    name: file.name,
-    mimeType: file.mimeType,
-    relativeId: file.path,
-    uploadOptions: {},
-  })
+  const getPendingCredits = async (): Promise<{ upload: number; download: number }> => {
+    const me = await apiCalls.getMe(api)
+    return {
+      upload: me.subscription.pendingUploadCredits,
+      download: me.subscription.pendingDownloadCredits,
+    }
+  }
 
-  await uploadFileChunks(api, fileUpload.id, file.read(), uploadChunkSize, options.onProgress)
+  const getSubscriptionInfo = async (): Promise<SubscriptionInfo> => {
+    const me = await apiCalls.getMe(api)
 
-  const result = await apiCalls.completeUpload(api, { uploadId: fileUpload.id })
+    return me.subscription
+  }
 
-  return result.cid
-}
+  const publishObject = async (cid: string): Promise<string> => {
+    const result = await apiCalls.publishObject(api, { cid })
 
-/**
- * Downloads a file from the AutoDrive service.
- *
- * @param {AutoDriveApi} api - The API instance to interact with the AutoDrive service.
- * @param {string} cid - The CID of the file to be downloaded.
- * @returns {Promise<ReadableStream<Uint8Array>>} A promise that resolves to a ReadableStream of the downloaded file.
- */
-export const downloadFile = async (
-  api: AutoDriveApi,
-  cid: string,
-  password?: string,
-): Promise<AsyncIterable<Buffer>> => {
-  const { decompressFile, CompressionAlgorithm, EncryptionAlgorithm, decryptFile } = await import(
-    '@autonomys/auto-dag-data'
-  )
-
-  const metadata = await apiCalls.getObjectMetadata(api, { cid })
-
-  let iterable = asyncFromStream(await apiCalls.downloadObject(api, { cid }))
-  if (metadata.uploadOptions?.encryption) {
-    if (!password) {
-      throw new Error('Password is required to decrypt the file')
-    }
-    iterable = decryptFile(iterable, password, {
-      algorithm: EncryptionAlgorithm.AES_256_GCM,
-    })
+    return publicDownloadUrl(api, result.result)
   }
 
-  if (metadata.uploadOptions?.compression) {
-    iterable = decompressFile(iterable, {
-      algorithm: CompressionAlgorithm.ZLIB,
+  const getMyFiles = async (
+    page: number,
+    limit: number = 100,
+  ): Promise<PaginatedResult<ObjectSummary>> => {
+    const result = await apiCalls.getRoots(api, {
+      scope: Scope.User,
+      limit,
+      offset: page * limit,
     })
+
+    return result
   }
 
-  return iterable
-}
+  const searchByNameOrCIDInMyFiles = async (value: string): Promise<ObjectSummary[]> => {
+    const results = await apiCalls.searchByNameOrCID(api, { value, scope: Scope.User })
 
-export const getPendingCredits = async (
-  api: AutoDriveApi,
-): Promise<{ upload: number; download: number }> => {
-  const me = await apiCalls.getMe(api)
-  return {
-    upload: me.subscription.pendingUploadCredits,
-    download: me.subscription.pendingDownloadCredits,
+    const summaries = await Promise.all(
+      results.map(async (e) => apiCalls.getObjectSummary(api, { cid: e.cid })),
+    )
+
+    return summaries
   }
-}
 
-export const getSubscriptionInfo = async (api: AutoDriveApi): Promise<SubscriptionInfo> => {
-  const me = await apiCalls.getMe(api)
+  const searchByNameOrCID = async (value: string): Promise<ObjectSummary[]> => {
+    const results = await apiCalls.searchByNameOrCID(api, { value, scope: Scope.Global })
 
-  return me.subscription
-}
+    const summaries = await Promise.all(
+      results.map(async (e) => apiCalls.getObjectSummary(api, { cid: e.cid })),
+    )
+
+    return summaries
+  }
 
-/**
- * Publishes an object by sending a request to the server.
- *
- * If already published, it will return the same public download URL.
- *
- * @param api {AutoDriveApi} - The API instance used to send requests.
- * @param cid {string} - The CID of the object to publish.
- * @returns {Promise<string>} - The public download URL of the published object.
- */
-export const publishObject = async (api: AutoDriveApi, cid: string): Promise<string> => {
-  const result = await apiCalls.publishObject(api, { cid })
-
-  return publicDownloadUrl(api, result.result)
+  return {
+    uploadFileFromInput,
+    uploadFile,
+    uploadObjectAsJSON,
+    uploadFolderFromInput,
+    uploadFileWithinFolderUpload,
+    downloadFile,
+    getPendingCredits,
+    getSubscriptionInfo,
+    publishObject,
+    getMyFiles,
+    searchByNameOrCIDInMyFiles,
+    searchByNameOrCID,
+    sendRequest: api.sendRequest,
+    baseUrl: api.baseUrl,
+  }
 }

package/src/fs/wrappers.ts

@@ -1,14 +1,13 @@
 import fs from 'fs'
 import mime from 'mime-types'
-import { AutoDriveApi } from '../api/connection.js'
-import { apiCalls } from '../api/index.js'
-import { GenericFileWithinFolder } from '../api/models/file.js'
-import { constructFromFileSystemEntries } from '../api/models/folderTree.js'
-import { CompressionAlgorithm } from '../api/models/uploads.js'
-import { uploadFile, UploadFileOptions, uploadFileWithinFolderUpload } from '../api/wrappers.js'
-import { fileToIterable } from '../utils/index.js'
-import { progressToPercentage } from '../utils/misc.js'
-import { constructZipFromTreeAndFileSystemPaths, getFiles } from './utils.js'
+import { apiCalls } from '../api/index'
+import { GenericFileWithinFolder } from '../api/models/file'
+import { constructFromFileSystemEntries } from '../api/models/folderTree'
+import { CompressionAlgorithm } from '../api/models/uploads'
+import { AutoDriveApi, UploadFileOptions } from '../api/types'
+import { fileToIterable } from '../utils/index'
+import { progressToPercentage } from '../utils/misc'
+import { constructZipFromTreeAndFileSystemPaths, getFiles } from './utils'
 
 /**
  * Uploads a file to the server with optional encryption and compression.
@@ -36,8 +35,7 @@ export const uploadFileFromFilepath = (
   const { password = undefined, compression = true, onProgress } = options
   const name = filePath.split('/').pop()!
 
-  return uploadFile(
-    api,
+  return api.uploadFile(
     {
       read: () => fs.createReadStream(filePath),
       name,
@@ -91,8 +89,7 @@ export const uploadFolderFromFolderPath = async (
     const filesMap = Object.fromEntries(files.map((file) => [file, file]))
     const zipBlob = await constructZipFromTreeAndFileSystemPaths(fileTree, filesMap)
     const name = folderPath.split('/').pop()!
-    return uploadFile(
-      api,
+    return api.uploadFile(
       {
         read: () => fileToIterable(zipBlob),
         name: `${name}.zip`,
@@ -130,7 +127,7 @@ export const uploadFolderFromFolderPath = async (
   const totalSize = genericFiles.reduce((acc, file) => acc + file.size, 0)
   let progress = 0
   for (const file of genericFiles) {
-    await uploadFileWithinFolderUpload(api, folderUpload.id, file, uploadChunkSize, {
+    await api.uploadFileWithinFolderUpload(folderUpload.id, file, uploadChunkSize, {
       onProgress: (uploadedBytes) => {
         onProgress?.(progressToPercentage(progress + uploadedBytes, totalSize))
       },

package/src/node.ts

@@ -1,2 +1,2 @@
-export * from './browser.js'
-export * from './fs/index.js'
+export * from './browser'
+export * as fs from './fs/index'