@supabase/storage-js 2.91.1 → 2.91.2

package/src/{lib/vectors → packages}/VectorIndexApi.ts

@@ -1,7 +1,7 @@
-import { DEFAULT_HEADERS } from './constants'
-import { isStorageVectorsError } from './errors'
-import { Fetch, post } from './fetch'
-import { resolveFetch } from './helpers'
+import { DEFAULT_HEADERS } from '../lib/constants'
+import { StorageError } from '../lib/common/errors'
+import { Fetch, post } from '../lib/common/fetch'
+import BaseApiClient from '../lib/common/BaseApiClient'
 import {
   ApiResponse,
   VectorIndex,
@@ -10,7 +10,7 @@ import {
   VectorDataType,
   DistanceMetric,
   MetadataConfiguration,
-} from './types'
+} from '../lib/types'
 
 /**
  * @alpha
@@ -33,41 +33,22 @@ export interface CreateIndexOptions {
  * Base implementation for vector index operations.
  * Use {@link VectorBucketScope} via `supabase.storage.vectors.from('bucket')` instead.
  */
-export default class VectorIndexApi {
-  protected url: string
-  protected headers: { [key: string]: string }
-  protected fetch: Fetch
-  protected shouldThrowOnError = false
-
+export default class VectorIndexApi extends BaseApiClient<StorageError> {
   /** Creates a new VectorIndexApi instance */
   constructor(url: string, headers: { [key: string]: string } = {}, fetch?: Fetch) {
-    this.url = url.replace(/\/$/, '')
-    this.headers = { ...DEFAULT_HEADERS, ...headers }
-    this.fetch = resolveFetch(fetch)
-  }
-
-  /** Enable throwing errors instead of returning them in the response */
-  public throwOnError(): this {
-    this.shouldThrowOnError = true
-    return this
+    const finalUrl = url.replace(/\/$/, '')
+    const finalHeaders = { ...DEFAULT_HEADERS, 'Content-Type': 'application/json', ...headers }
+    super(finalUrl, finalHeaders, fetch, 'vectors')
   }
 
   /** Creates a new vector index within a bucket */
   async createIndex(options: CreateIndexOptions): Promise<ApiResponse<undefined>> {
-    try {
+    return this.handleOperation(async () => {
       const data = await post(this.fetch, `${this.url}/CreateIndex`, options, {
         headers: this.headers,
       })
-      return { data: data || {}, error: null }
-    } catch (error) {
-      if (this.shouldThrowOnError) {
-        throw error
-      }
-      if (isStorageVectorsError(error)) {
-        return { data: null, error }
-      }
-      throw error
-    }
+      return data || {}
+    })
   }
 
   /** Retrieves metadata for a specific vector index */
@@ -75,61 +56,35 @@ export default class VectorIndexApi {
     vectorBucketName: string,
     indexName: string
   ): Promise<ApiResponse<{ index: VectorIndex }>> {
-    try {
-      const data = await post(
+    return this.handleOperation(async () => {
+      return await post(
         this.fetch,
         `${this.url}/GetIndex`,
         { vectorBucketName, indexName },
         { headers: this.headers }
       )
-      return { data, error: null }
-    } catch (error) {
-      if (this.shouldThrowOnError) {
-        throw error
-      }
-      if (isStorageVectorsError(error)) {
-        return { data: null, error }
-      }
-      throw error
-    }
+    })
   }
 
   /** Lists vector indexes within a bucket with optional filtering and pagination */
   async listIndexes(options: ListIndexesOptions): Promise<ApiResponse<ListIndexesResponse>> {
-    try {
-      const data = await post(this.fetch, `${this.url}/ListIndexes`, options, {
+    return this.handleOperation(async () => {
+      return await post(this.fetch, `${this.url}/ListIndexes`, options, {
         headers: this.headers,
       })
-      return { data, error: null }
-    } catch (error) {
-      if (this.shouldThrowOnError) {
-        throw error
-      }
-      if (isStorageVectorsError(error)) {
-        return { data: null, error }
-      }
-      throw error
-    }
+    })
   }
 
   /** Deletes a vector index and all its data */
   async deleteIndex(vectorBucketName: string, indexName: string): Promise<ApiResponse<undefined>> {
-    try {
+    return this.handleOperation(async () => {
       const data = await post(
         this.fetch,
         `${this.url}/DeleteIndex`,
         { vectorBucketName, indexName },
         { headers: this.headers }
       )
-      return { data: data || {}, error: null }
-    } catch (error) {
-      if (this.shouldThrowOnError) {
-        throw error
-      }
-      if (isStorageVectorsError(error)) {
-        return { data: null, error }
-      }
-      throw error
-    }
+      return data || {}
+    })
   }
 }

package/src/lib/errors.ts

@@ -1,43 +0,0 @@
-export class StorageError extends Error {
-  protected __isStorageError = true
-
-  constructor(message: string) {
-    super(message)
-    this.name = 'StorageError'
-  }
-}
-
-export function isStorageError(error: unknown): error is StorageError {
-  return typeof error === 'object' && error !== null && '__isStorageError' in error
-}
-
-export class StorageApiError extends StorageError {
-  status: number
-  statusCode: string
-
-  constructor(message: string, status: number, statusCode: string) {
-    super(message)
-    this.name = 'StorageApiError'
-    this.status = status
-    this.statusCode = statusCode
-  }
-
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      status: this.status,
-      statusCode: this.statusCode,
-    }
-  }
-}
-
-export class StorageUnknownError extends StorageError {
-  originalError: unknown
-
-  constructor(message: string, originalError: unknown) {
-    super(message)
-    this.name = 'StorageUnknownError'
-    this.originalError = originalError
-  }
-}

package/src/lib/fetch.ts

@@ -1,148 +0,0 @@
-import { StorageApiError, StorageUnknownError } from './errors'
-import { isPlainObject, resolveResponse } from './helpers'
-import { FetchParameters } from './types'
-
-export type Fetch = typeof fetch
-
-export interface FetchOptions {
-  headers?: {
-    [key: string]: string
-  }
-  duplex?: string
-  noResolveJson?: boolean
-}
-
-export type RequestMethodType = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD'
-
-const _getErrorMessage = (err: any): string =>
-  err.msg ||
-  err.message ||
-  err.error_description ||
-  (typeof err.error === 'string' ? err.error : err.error?.message) ||
-  JSON.stringify(err)
-
-const handleError = async (
-  error: unknown,
-  reject: (reason?: any) => void,
-  options?: FetchOptions
-) => {
-  const Res = await resolveResponse()
-
-  if (error instanceof Res && !options?.noResolveJson) {
-    error
-      .json()
-      .then((err) => {
-        const status = error.status || 500
-        const statusCode = err?.statusCode || status + ''
-        reject(new StorageApiError(_getErrorMessage(err), status, statusCode))
-      })
-      .catch((err) => {
-        reject(new StorageUnknownError(_getErrorMessage(err), err))
-      })
-  } else {
-    reject(new StorageUnknownError(_getErrorMessage(error), error))
-  }
-}
-
-const _getRequestParams = (
-  method: RequestMethodType,
-  options?: FetchOptions,
-  parameters?: FetchParameters,
-  body?: object
-) => {
-  const params: { [k: string]: any } = { method, headers: options?.headers || {} }
-
-  if (method === 'GET' || !body) {
-    return params
-  }
-
-  if (isPlainObject(body)) {
-    params.headers = { 'Content-Type': 'application/json', ...options?.headers }
-    params.body = JSON.stringify(body)
-  } else {
-    params.body = body
-  }
-
-  if (options?.duplex) {
-    params.duplex = options.duplex
-  }
-
-  return { ...params, ...parameters }
-}
-
-async function _handleRequest(
-  fetcher: Fetch,
-  method: RequestMethodType,
-  url: string,
-  options?: FetchOptions,
-  parameters?: FetchParameters,
-  body?: object
-): Promise<any> {
-  return new Promise((resolve, reject) => {
-    fetcher(url, _getRequestParams(method, options, parameters, body))
-      .then((result) => {
-        if (!result.ok) throw result
-        if (options?.noResolveJson) return result
-        return result.json()
-      })
-      .then((data) => resolve(data))
-      .catch((error) => handleError(error, reject, options))
-  })
-}
-
-export async function get(
-  fetcher: Fetch,
-  url: string,
-  options?: FetchOptions,
-  parameters?: FetchParameters
-): Promise<any> {
-  return _handleRequest(fetcher, 'GET', url, options, parameters)
-}
-
-export async function post(
-  fetcher: Fetch,
-  url: string,
-  body: object,
-  options?: FetchOptions,
-  parameters?: FetchParameters
-): Promise<any> {
-  return _handleRequest(fetcher, 'POST', url, options, parameters, body)
-}
-
-export async function put(
-  fetcher: Fetch,
-  url: string,
-  body: object,
-  options?: FetchOptions,
-  parameters?: FetchParameters
-): Promise<any> {
-  return _handleRequest(fetcher, 'PUT', url, options, parameters, body)
-}
-
-export async function head(
-  fetcher: Fetch,
-  url: string,
-  options?: FetchOptions,
-  parameters?: FetchParameters
-): Promise<any> {
-  return _handleRequest(
-    fetcher,
-    'HEAD',
-    url,
-    {
-      ...options,
-      noResolveJson: true,
-    },
-    parameters
-  )
-}
-
-export async function remove(
-  fetcher: Fetch,
-  url: string,
-  body: object,
-  options?: FetchOptions,
-  parameters?: FetchParameters
-): Promise<any> {
-  return _handleRequest(fetcher, 'DELETE', url, options, parameters, body)
-}

package/src/lib/index.ts

@@ -1,5 +0,0 @@
-export * from '../packages/StorageBucketApi'
-export * from '../packages/StorageFileApi'
-export * from './types'
-export * from './constants'
-export * from './vectors'

package/src/lib/vectors/VectorBucketApi.ts

@@ -1,118 +0,0 @@
-import { DEFAULT_HEADERS } from './constants'
-import { isStorageVectorsError } from './errors'
-import { Fetch, post } from './fetch'
-import { resolveFetch } from './helpers'
-import {
-  ApiResponse,
-  VectorBucket,
-  ListVectorBucketsOptions,
-  ListVectorBucketsResponse,
-} from './types'
-
-/**
- * @hidden
- * Base implementation for vector bucket operations.
- * Use {@link StorageVectorsClient} via `supabase.storage.vectors` instead.
- */
-export default class VectorBucketApi {
-  protected url: string
-  protected headers: { [key: string]: string }
-  protected fetch: Fetch
-  protected shouldThrowOnError = false
-
-  /** Creates a new VectorBucketApi instance */
-  constructor(url: string, headers: { [key: string]: string } = {}, fetch?: Fetch) {
-    this.url = url.replace(/\/$/, '')
-    this.headers = { ...DEFAULT_HEADERS, ...headers }
-    this.fetch = resolveFetch(fetch)
-  }
-
-  /** Enable throwing errors instead of returning them in the response */
-  public throwOnError(): this {
-    this.shouldThrowOnError = true
-    return this
-  }
-
-  /** Creates a new vector bucket */
-  async createBucket(vectorBucketName: string): Promise<ApiResponse<undefined>> {
-    try {
-      const data = await post(
-        this.fetch,
-        `${this.url}/CreateVectorBucket`,
-        { vectorBucketName },
-        { headers: this.headers }
-      )
-      return { data: data || {}, error: null }
-    } catch (error) {
-      if (this.shouldThrowOnError) {
-        throw error
-      }
-      if (isStorageVectorsError(error)) {
-        return { data: null, error }
-      }
-      throw error
-    }
-  }
-
-  /** Retrieves metadata for a specific vector bucket */
-  async getBucket(vectorBucketName: string): Promise<ApiResponse<{ vectorBucket: VectorBucket }>> {
-    try {
-      const data = await post(
-        this.fetch,
-        `${this.url}/GetVectorBucket`,
-        { vectorBucketName },
-        { headers: this.headers }
-      )
-      return { data, error: null }
-    } catch (error) {
-      if (this.shouldThrowOnError) {
-        throw error
-      }
-      if (isStorageVectorsError(error)) {
-        return { data: null, error }
-      }
-      throw error
-    }
-  }
-
-  /** Lists vector buckets with optional filtering and pagination */
-  async listBuckets(
-    options: ListVectorBucketsOptions = {}
-  ): Promise<ApiResponse<ListVectorBucketsResponse>> {
-    try {
-      const data = await post(this.fetch, `${this.url}/ListVectorBuckets`, options, {
-        headers: this.headers,
-      })
-      return { data, error: null }
-    } catch (error) {
-      if (this.shouldThrowOnError) {
-        throw error
-      }
-      if (isStorageVectorsError(error)) {
-        return { data: null, error }
-      }
-      throw error
-    }
-  }
-
-  /** Deletes a vector bucket (must be empty first) */
-  async deleteBucket(vectorBucketName: string): Promise<ApiResponse<undefined>> {
-    try {
-      const data = await post(
-        this.fetch,
-        `${this.url}/DeleteVectorBucket`,
-        { vectorBucketName },
-        { headers: this.headers }
-      )
-      return { data: data || {}, error: null }
-    } catch (error) {
-      if (this.shouldThrowOnError) {
-        throw error
-      }
-      if (isStorageVectorsError(error)) {
-        return { data: null, error }
-      }
-      throw error
-    }
-  }
-}

package/src/lib/vectors/VectorDataApi.ts

@@ -1,152 +0,0 @@
-import { DEFAULT_HEADERS } from './constants'
-import { isStorageVectorsError } from './errors'
-import { Fetch, post } from './fetch'
-import { resolveFetch } from './helpers'
-import {
-  ApiResponse,
-  PutVectorsOptions,
-  GetVectorsOptions,
-  GetVectorsResponse,
-  DeleteVectorsOptions,
-  ListVectorsOptions,
-  ListVectorsResponse,
-  QueryVectorsOptions,
-  QueryVectorsResponse,
-} from './types'
-
-/**
- * @hidden
- * Base implementation for vector data operations.
- * Use {@link VectorIndexScope} via `supabase.storage.vectors.from('bucket').index('idx')` instead.
- */
-export default class VectorDataApi {
-  protected url: string
-  protected headers: { [key: string]: string }
-  protected fetch: Fetch
-  protected shouldThrowOnError = false
-
-  /** Creates a new VectorDataApi instance */
-  constructor(url: string, headers: { [key: string]: string } = {}, fetch?: Fetch) {
-    this.url = url.replace(/\/$/, '')
-    this.headers = { ...DEFAULT_HEADERS, ...headers }
-    this.fetch = resolveFetch(fetch)
-  }
-
-  /** Enable throwing errors instead of returning them in the response */
-  public throwOnError(): this {
-    this.shouldThrowOnError = true
-    return this
-  }
-
-  /** Inserts or updates vectors in batch (1-500 per request) */
-  async putVectors(options: PutVectorsOptions): Promise<ApiResponse<undefined>> {
-    try {
-      // Validate batch size
-      if (options.vectors.length < 1 || options.vectors.length > 500) {
-        throw new Error('Vector batch size must be between 1 and 500 items')
-      }
-
-      const data = await post(this.fetch, `${this.url}/PutVectors`, options, {
-        headers: this.headers,
-      })
-      return { data: data || {}, error: null }
-    } catch (error) {
-      if (this.shouldThrowOnError) {
-        throw error
-      }
-      if (isStorageVectorsError(error)) {
-        return { data: null, error }
-      }
-      throw error
-    }
-  }
-
-  /** Retrieves vectors by their keys in batch */
-  async getVectors(options: GetVectorsOptions): Promise<ApiResponse<GetVectorsResponse>> {
-    try {
-      const data = await post(this.fetch, `${this.url}/GetVectors`, options, {
-        headers: this.headers,
-      })
-      return { data, error: null }
-    } catch (error) {
-      if (this.shouldThrowOnError) {
-        throw error
-      }
-      if (isStorageVectorsError(error)) {
-        return { data: null, error }
-      }
-      throw error
-    }
-  }
-
-  /** Lists vectors in an index with pagination */
-  async listVectors(options: ListVectorsOptions): Promise<ApiResponse<ListVectorsResponse>> {
-    try {
-      // Validate segment configuration
-      if (options.segmentCount !== undefined) {
-        if (options.segmentCount < 1 || options.segmentCount > 16) {
-          throw new Error('segmentCount must be between 1 and 16')
-        }
-        if (options.segmentIndex !== undefined) {
-          if (options.segmentIndex < 0 || options.segmentIndex >= options.segmentCount) {
-            throw new Error(`segmentIndex must be between 0 and ${options.segmentCount - 1}`)
-          }
-        }
-      }
-
-      const data = await post(this.fetch, `${this.url}/ListVectors`, options, {
-        headers: this.headers,
-      })
-      return { data, error: null }
-    } catch (error) {
-      if (this.shouldThrowOnError) {
-        throw error
-      }
-      if (isStorageVectorsError(error)) {
-        return { data: null, error }
-      }
-      throw error
-    }
-  }
-
-  /** Queries for similar vectors using approximate nearest neighbor search */
-  async queryVectors(options: QueryVectorsOptions): Promise<ApiResponse<QueryVectorsResponse>> {
-    try {
-      const data = await post(this.fetch, `${this.url}/QueryVectors`, options, {
-        headers: this.headers,
-      })
-      return { data, error: null }
-    } catch (error) {
-      if (this.shouldThrowOnError) {
-        throw error
-      }
-      if (isStorageVectorsError(error)) {
-        return { data: null, error }
-      }
-      throw error
-    }
-  }
-
-  /** Deletes vectors by their keys in batch (1-500 per request) */
-  async deleteVectors(options: DeleteVectorsOptions): Promise<ApiResponse<undefined>> {
-    try {
-      // Validate batch size
-      if (options.keys.length < 1 || options.keys.length > 500) {
-        throw new Error('Keys batch size must be between 1 and 500 items')
-      }
-
-      const data = await post(this.fetch, `${this.url}/DeleteVectors`, options, {
-        headers: this.headers,
-      })
-      return { data: data || {}, error: null }
-    } catch (error) {
-      if (this.shouldThrowOnError) {
-        throw error
-      }
-      if (isStorageVectorsError(error)) {
-        return { data: null, error }
-      }
-      throw error
-    }
-  }
-}

package/src/lib/vectors/constants.ts

@@ -1,5 +0,0 @@
-import { version } from '../version'
-export const DEFAULT_HEADERS = {
-  'X-Client-Info': `storage-js/${version}`,
-  'Content-Type': 'application/json',
-}

package/src/lib/vectors/errors.ts

@@ -1,78 +0,0 @@
-/**
- * Base error class for all Storage Vectors errors
- */
-export class StorageVectorsError extends Error {
-  protected __isStorageVectorsError = true
-
-  constructor(message: string) {
-    super(message)
-    this.name = 'StorageVectorsError'
-  }
-}
-
-/**
- * Type guard to check if an error is a StorageVectorsError
- * @param error - The error to check
- * @returns True if the error is a StorageVectorsError
- */
-export function isStorageVectorsError(error: unknown): error is StorageVectorsError {
-  return typeof error === 'object' && error !== null && '__isStorageVectorsError' in error
-}
-
-/**
- * API error returned from S3 Vectors service
- * Includes HTTP status code and service-specific error code
- */
-export class StorageVectorsApiError extends StorageVectorsError {
-  status: number
-  statusCode: string
-
-  constructor(message: string, status: number, statusCode: string) {
-    super(message)
-    this.name = 'StorageVectorsApiError'
-    this.status = status
-    this.statusCode = statusCode
-  }
-
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      status: this.status,
-      statusCode: this.statusCode,
-    }
-  }
-}
-
-/**
- * Unknown error that doesn't match expected error patterns
- * Wraps the original error for debugging
- */
-export class StorageVectorsUnknownError extends StorageVectorsError {
-  originalError: unknown
-
-  constructor(message: string, originalError: unknown) {
-    super(message)
-    this.name = 'StorageVectorsUnknownError'
-    this.originalError = originalError
-  }
-}
-
-/**
- * Error codes specific to S3 Vectors API
- * Maps AWS service errors to application-friendly error codes
- */
-export enum StorageVectorsErrorCode {
-  /** Internal server fault (HTTP 500) */
-  InternalError = 'InternalError',
-  /** Resource already exists / conflict (HTTP 409) */
-  S3VectorConflictException = 'S3VectorConflictException',
-  /** Resource not found (HTTP 404) */
-  S3VectorNotFoundException = 'S3VectorNotFoundException',
-  /** Delete bucket while not empty (HTTP 400) */
-  S3VectorBucketNotEmpty = 'S3VectorBucketNotEmpty',
-  /** Exceeds bucket quota/limit (HTTP 400) */
-  S3VectorMaxBucketsExceeded = 'S3VectorMaxBucketsExceeded',
-  /** Exceeds index quota/limit (HTTP 400) */
-  S3VectorMaxIndexesExceeded = 'S3VectorMaxIndexesExceeded',
-}