@geenius/adapters 0.1.0 → 0.3.0

package/packages/shared/src/storage/s3.ts

@@ -1,128 +0,0 @@
-// @geenius/adapters — AWS S3 file storage adapter
-// Requires: @aws-sdk/client-s3, @aws-sdk/s3-request-presigner
-
-import type { StoredFile } from '../types'
-import type { FileStorageAdapter } from './interface'
-
-export interface S3FileAdapterOptions {
-  /** AWS region */
-  region: string
-  /** S3 bucket name */
-  bucket: string
-  /** AWS access key ID (optional if using IAM roles) */
-  accessKeyId?: string
-  /** AWS secret access key (optional if using IAM roles) */
-  secretAccessKey?: string
-  /** Custom endpoint (for S3-compatible services) */
-  endpoint?: string
-  /** Custom public URL prefix (e.g. CloudFront distribution) */
-  publicUrl?: string
-  /** Presigned URL expiry in seconds (default: 3600) */
-  presignedExpiry?: number
-}
-
-export function createS3FileAdapter(options: S3FileAdapterOptions): FileStorageAdapter {
-  const { region, bucket, accessKeyId, secretAccessKey, endpoint, publicUrl, presignedExpiry = 3600 } = options
-
-  let s3Client: any = null
-  let getSignedUrl: any = null
-  let commands: any = null
-
-  async function getClient() {
-    if (!s3Client) {
-      const { S3Client } = await import('@aws-sdk/client-s3')
-      const presigner = await import('@aws-sdk/s3-request-presigner')
-      const s3Commands = await import('@aws-sdk/client-s3')
-
-      const clientConfig: any = { region, endpoint }
-      if (accessKeyId && secretAccessKey) {
-        clientConfig.credentials = { accessKeyId, secretAccessKey }
-      }
-
-      s3Client = new S3Client(clientConfig)
-      getSignedUrl = presigner.getSignedUrl
-      commands = s3Commands
-    }
-    return { client: s3Client, getSignedUrl, commands }
-  }
-
-  return {
-    async upload(file, path, name?) {
-      const { client, commands: cmd } = await getClient()
-      const id = crypto.randomUUID()
-      const fileName = name || (file instanceof File ? file.name : `file-${id.slice(0, 8)}`)
-      const key = path ? `${path}/${fileName}` : fileName
-      const buffer = new Uint8Array(await file.arrayBuffer())
-
-      await client.send(new cmd.PutObjectCommand({
-        Bucket: bucket,
-        Key: key,
-        Body: buffer,
-        ContentType: file.type || 'application/octet-stream',
-        Metadata: { 'original-name': fileName, 'file-id': id },
-      }))
-
-      const url = publicUrl
-        ? `${publicUrl}/${key}`
-        : `https://${bucket}.s3.${region}.amazonaws.com/${key}`
-
-      return {
-        id,
-        name: fileName,
-        path: key,
-        size: file.size,
-        mimeType: file.type || 'application/octet-stream',
-        url,
-        createdAt: new Date().toISOString(),
-      }
-    },
-
-    async download(fileId) {
-      const { client, commands: cmd } = await getClient()
-      const response = await client.send(new cmd.GetObjectCommand({
-        Bucket: bucket,
-        Key: fileId,
-      }))
-      const bytes = await response.Body?.transformToByteArray()
-      if (!bytes) throw new Error(`Failed to download file: ${fileId}`)
-      return new Blob([bytes], { type: response.ContentType || 'application/octet-stream' })
-    },
-
-    async delete(fileId) {
-      const { client, commands: cmd } = await getClient()
-      try {
-        await client.send(new cmd.DeleteObjectCommand({ Bucket: bucket, Key: fileId }))
-        return true
-      } catch {
-        return false
-      }
-    },
-
-    async list(prefix?) {
-      const { client, commands: cmd } = await getClient()
-      const response = await client.send(new cmd.ListObjectsV2Command({
-        Bucket: bucket,
-        Prefix: prefix || undefined,
-      }))
-
-      return (response.Contents || []).map((obj: any): StoredFile => ({
-        id: obj.Key,
-        name: obj.Key.split('/').pop() || obj.Key,
-        path: obj.Key,
-        size: obj.Size || 0,
-        mimeType: 'application/octet-stream',
-        url: publicUrl
-          ? `${publicUrl}/${obj.Key}`
-          : `https://${bucket}.s3.${region}.amazonaws.com/${obj.Key}`,
-        createdAt: obj.LastModified?.toISOString() || new Date().toISOString(),
-      }))
-    },
-
-    async getUrl(fileId) {
-      if (publicUrl) return `${publicUrl}/${fileId}`
-      const { client, getSignedUrl: sign, commands: cmd } = await getClient()
-      const command = new cmd.GetObjectCommand({ Bucket: bucket, Key: fileId })
-      return sign(client, command, { expiresIn: presignedExpiry })
-    },
-  }
-}

package/packages/shared/src/storage/supabase-storage.ts

@@ -1,116 +0,0 @@
-// @geenius/adapters — Supabase Storage file adapter
-// Requires: @supabase/supabase-js
-
-import type { StoredFile } from '../types'
-import type { FileStorageAdapter } from './interface'
-
-export interface SupabaseFileAdapterOptions {
-  /** Supabase project URL */
-  supabaseUrl: string
-  /** Supabase service role key or anon key */
-  supabaseKey: string
-  /** Storage bucket name (default: 'files') */
-  bucket?: string
-}
-
-export function createSupabaseFileAdapter(options: SupabaseFileAdapterOptions): FileStorageAdapter {
-  const { supabaseUrl, supabaseKey, bucket = 'files' } = options
-
-  let supabase: any = null
-
-  async function getClient() {
-    if (!supabase) {
-      const { createClient } = await import('@supabase/supabase-js')
-      supabase = createClient(supabaseUrl, supabaseKey)
-    }
-    return supabase
-  }
-
-  return {
-    async upload(file, path, name?) {
-      const client = await getClient()
-      const id = crypto.randomUUID()
-      const fileName = name || (file instanceof File ? file.name : `file-${id.slice(0, 8)}`)
-      const filePath = path ? `${path}/${fileName}` : fileName
-
-      const { error } = await client.storage
-        .from(bucket)
-        .upload(filePath, file, {
-          contentType: file.type || 'application/octet-stream',
-          upsert: false,
-        })
-
-      if (error) throw new Error(`Supabase upload failed: ${error.message}`)
-
-      const { data: urlData } = client.storage
-        .from(bucket)
-        .getPublicUrl(filePath)
-
-      return {
-        id,
-        name: fileName,
-        path: filePath,
-        size: file.size,
-        mimeType: file.type || 'application/octet-stream',
-        url: urlData.publicUrl,
-        createdAt: new Date().toISOString(),
-      }
-    },
-
-    async download(fileId) {
-      const client = await getClient()
-      const { data, error } = await client.storage
-        .from(bucket)
-        .download(fileId)
-
-      if (error || !data) throw new Error(`Supabase download failed: ${error?.message || 'No data'}`)
-      return data
-    },
-
-    async delete(fileId) {
-      const client = await getClient()
-      const { error } = await client.storage
-        .from(bucket)
-        .remove([fileId])
-
-      return !error
-    },
-
-    async list(prefix?) {
-      const client = await getClient()
-      const { data, error } = await client.storage
-        .from(bucket)
-        .list(prefix || '', { limit: 1000, sortBy: { column: 'created_at', order: 'desc' } })
-
-      if (error || !data) return []
-
-      return data
-        .filter((f: any) => f.name) // filter out folders
-        .map((f: any): StoredFile => {
-          const filePath = prefix ? `${prefix}/${f.name}` : f.name
-          const { data: urlData } = client.storage
-            .from(bucket)
-            .getPublicUrl(filePath)
-
-          return {
-            id: f.id || filePath,
-            name: f.name,
-            path: filePath,
-            size: f.metadata?.size || 0,
-            mimeType: f.metadata?.mimetype || 'application/octet-stream',
-            url: urlData.publicUrl,
-            createdAt: f.created_at || new Date().toISOString(),
-          }
-        })
-    },
-
-    async getUrl(fileId) {
-      const client = await getClient()
-      const { data } = client.storage
-        .from(bucket)
-        .getPublicUrl(fileId)
-
-      return data.publicUrl
-    },
-  }
-}

package/packages/shared/src/storage/uploadthing.ts

@@ -1,126 +0,0 @@
-// @geenius/adapters — Uploadthing file storage adapter
-// Requires: uploadthing
-
-import type { StoredFile } from '../types'
-import type { FileStorageAdapter } from './interface'
-
-export interface UploadthingFileAdapterOptions {
-  /** Uploadthing API token */
-  token: string
-  /** Base URL for the Uploadthing API (default: https://api.uploadthing.com) */
-  apiUrl?: string
-}
-
-export function createUploadthingFileAdapter(options: UploadthingFileAdapterOptions): FileStorageAdapter {
-  const { token, apiUrl = 'https://api.uploadthing.com' } = options
-
-  const headers = {
-    'Content-Type': 'application/json',
-    'x-uploadthing-api-key': token,
-  }
-
-  return {
-    async upload(file, path, name?) {
-      const id = crypto.randomUUID()
-      const fileName = name || (file instanceof File ? file.name : `file-${id.slice(0, 8)}`)
-
-      // Request a presigned URL from Uploadthing
-      const presignResponse = await fetch(`${apiUrl}/v6/uploadFiles`, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify({
-          files: [{
-            name: fileName,
-            size: file.size,
-            type: file.type || 'application/octet-stream',
-            customId: id,
-          }],
-          acl: 'public-read',
-          contentDisposition: 'inline',
-        }),
-      })
-
-      if (!presignResponse.ok) {
-        throw new Error(`Uploadthing presign failed: ${presignResponse.statusText}`)
-      }
-
-      const presignData = await presignResponse.json()
-      const upload = presignData.data?.[0]
-
-      if (!upload?.url) {
-        throw new Error('Uploadthing did not return an upload URL')
-      }
-
-      // Upload the file to the presigned URL
-      const formData = new FormData()
-      for (const [key, value] of Object.entries(upload.fields || {})) {
-        formData.append(key, value as string)
-      }
-      formData.append('file', file)
-
-      const uploadResponse = await fetch(upload.url, {
-        method: 'POST',
-        body: formData,
-      })
-
-      if (!uploadResponse.ok) {
-        throw new Error(`Uploadthing upload failed: ${uploadResponse.statusText}`)
-      }
-
-      return {
-        id: upload.key || id,
-        name: fileName,
-        path: path ? `${path}/${fileName}` : fileName,
-        size: file.size,
-        mimeType: file.type || 'application/octet-stream',
-        url: upload.fileUrl || `https://utfs.io/f/${upload.key}`,
-        createdAt: new Date().toISOString(),
-      }
-    },
-
-    async download(fileId) {
-      const url = fileId.startsWith('http') ? fileId : `https://utfs.io/f/${fileId}`
-      const response = await fetch(url)
-      if (!response.ok) throw new Error(`Failed to download file: ${fileId}`)
-      return response.blob()
-    },
-
-    async delete(fileId) {
-      try {
-        const response = await fetch(`${apiUrl}/v6/deleteFiles`, {
-          method: 'POST',
-          headers,
-          body: JSON.stringify({ fileKeys: [fileId] }),
-        })
-        return response.ok
-      } catch {
-        return false
-      }
-    },
-
-    async list(prefix?) {
-      const response = await fetch(`${apiUrl}/v6/listFiles`, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify({ prefix }),
-      })
-
-      if (!response.ok) return []
-
-      const data = await response.json()
-      return (data.files || []).map((f: any): StoredFile => ({
-        id: f.key,
-        name: f.name || f.key,
-        path: f.key,
-        size: f.size || 0,
-        mimeType: f.type || 'application/octet-stream',
-        url: f.url || `https://utfs.io/f/${f.key}`,
-        createdAt: f.uploadedAt || new Date().toISOString(),
-      }))
-    },
-
-    async getUrl(fileId) {
-      return fileId.startsWith('http') ? fileId : `https://utfs.io/f/${fileId}`
-    },
-  }
-}