@geenius/adapters 0.1.0

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

@@ -0,0 +1,128 @@
+// @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

@@ -0,0 +1,116 @@
+// @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

@@ -0,0 +1,126 @@
+// @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}`
+    },
+  }
+}