release: v1.1.0 — S3 multi-backend storage and admin UI

server/utils/storage/s3.ts

@@ -0,0 +1,218 @@
+import {
+  DeleteObjectCommand,
+  GetObjectCommand,
+  HeadBucketCommand,
+  HeadObjectCommand,
+  PutObjectCommand,
+  S3Client
+} from '@aws-sdk/client-s3'
+import type { Readable } from 'node:stream'
+import { validateImageKey } from '../image-key'
+import type {
+  S3BackendConfig,
+  S3BackendSecrets,
+  ServingMode,
+  StoredImage,
+  StoredImageMeta,
+  StorageBackend
+} from './types'
+
+function contentTypeFromKey(key: string): string {
+  const ext = key.split('.').pop()?.toLowerCase()
+  switch (ext) {
+    case 'jpg':
+    case 'jpeg':
+      return 'image/jpeg'
+    case 'png':
+      return 'image/png'
+    case 'gif':
+      return 'image/gif'
+    case 'webp':
+      return 'image/webp'
+    case 'svg':
+      return 'image/svg+xml'
+    case 'ico':
+      return 'image/x-icon'
+    default:
+      return 'application/octet-stream'
+  }
+}
+
+export function buildObjectKey(prefix: string | undefined, key: string): string {
+  const trimmed = prefix?.replace(/^\/+|\/+$/g, '') ?? ''
+  return trimmed ? `${trimmed}/${key}` : key
+}
+
+export function parseS3Config(raw: string): S3BackendConfig | null {
+  try {
+    const parsed = JSON.parse(raw) as Partial<S3BackendConfig>
+    if (!parsed.endpoint || !parsed.region || !parsed.bucket) return null
+    return {
+      endpoint: parsed.endpoint,
+      region: parsed.region,
+      bucket: parsed.bucket,
+      prefix: parsed.prefix,
+      forcePathStyle: parsed.forcePathStyle ?? false
+    }
+  } catch {
+    return null
+  }
+}
+
+export function parseS3Secrets(raw: string): S3BackendSecrets | null {
+  try {
+    const parsed = JSON.parse(raw) as Partial<S3BackendSecrets>
+    if (!parsed.accessKeyId || !parsed.secretAccessKey) return null
+    return {
+      accessKeyId: parsed.accessKeyId,
+      secretAccessKey: parsed.secretAccessKey
+    }
+  } catch {
+    return null
+  }
+}
+
+export function validateS3Config(config: S3BackendConfig): string | null {
+  if (!config.endpoint.startsWith('http')) {
+    return 'Endpoint 需为 http(s) 地址'
+  }
+  if (!config.bucket.trim()) {
+    return 'Bucket 不能为空'
+  }
+  return null
+}
+
+export class S3StorageBackend implements StorageBackend {
+  readonly id: string
+  readonly type = 's3' as const
+  readonly servingMode: ServingMode
+  readonly publicUrl: string
+  private readonly client: S3Client
+  private readonly bucket: string
+  private readonly prefix: string | undefined
+
+  constructor(
+    id: string,
+    config: S3BackendConfig,
+    secrets: S3BackendSecrets,
+    servingMode: ServingMode = 'proxy',
+    publicUrl = ''
+  ) {
+    this.id = id
+    this.servingMode = servingMode
+    this.publicUrl = publicUrl
+    this.bucket = config.bucket
+    this.prefix = config.prefix
+    this.client = new S3Client({
+      endpoint: config.endpoint,
+      region: config.region,
+      credentials: {
+        accessKeyId: secrets.accessKeyId,
+        secretAccessKey: secrets.secretAccessKey
+      },
+      forcePathStyle: config.forcePathStyle ?? false
+    })
+  }
+
+  private objectKey(key: string): string {
+    return buildObjectKey(this.prefix, key)
+  }
+
+  async put(key: string, bytes: Uint8Array, meta: StoredImageMeta): Promise<void> {
+    await this.client.send(new PutObjectCommand({
+      Bucket: this.bucket,
+      Key: this.objectKey(key),
+      Body: bytes,
+      ContentType: meta.contentType,
+      Metadata: {
+        originalName: meta.originalName,
+        uploadedAt: meta.uploadedAt,
+        userId: meta.userId != null ? String(meta.userId) : ''
+      }
+    }))
+  }
+
+  async head(key: string): Promise<StoredImage | null> {
+    if (!validateImageKey(key)) return null
+
+    try {
+      const response = await this.client.send(new HeadObjectCommand({
+        Bucket: this.bucket,
+        Key: this.objectKey(key)
+      }))
+
+      const uploadedAt = response.Metadata?.uploadedat
+        ?? response.LastModified?.toISOString()
+        ?? new Date().toISOString()
+      const originalName = response.Metadata?.originalname
+        ?? key.split('/').pop()
+        ?? 'image'
+      const userIdRaw = response.Metadata?.userid
+      const userId = userIdRaw ? Number(userIdRaw) : null
+
+      return {
+        key,
+        size: response.ContentLength ?? 0,
+        mtimeMs: response.LastModified?.getTime() ?? Date.now(),
+        contentType: response.ContentType ?? contentTypeFromKey(key),
+        originalName,
+        uploadedAt,
+        userId: Number.isFinite(userId) ? userId : null,
+        backendId: this.id
+      }
+    } catch {
+      return null
+    }
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.client.send(new DeleteObjectCommand({
+      Bucket: this.bucket,
+      Key: this.objectKey(key)
+    }))
+  }
+
+  async createStream(
+    key: string,
+    range?: { start: number, end: number }
+  ): Promise<Readable> {
+    const response = await this.client.send(new GetObjectCommand({
+      Bucket: this.bucket,
+      Key: this.objectKey(key),
+      Range: range ? `bytes=${range.start}-${range.end}` : undefined
+    }))
+
+    if (!response.Body) {
+      throw new Error('Empty S3 response body')
+    }
+
+    return response.Body as Readable
+  }
+
+  async testConnection(): Promise<{ ok: boolean, message: string }> {
+    const probeKey = `__pichost-probe-${Date.now()}.txt`
+    const probeBytes = new TextEncoder().encode('pichost-probe')
+
+    try {
+      await this.client.send(new HeadBucketCommand({ Bucket: this.bucket }))
+      await this.client.send(new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: buildObjectKey(this.prefix, probeKey),
+        Body: probeBytes,
+        ContentType: 'text/plain'
+      }))
+      await this.client.send(new DeleteObjectCommand({
+        Bucket: this.bucket,
+        Key: buildObjectKey(this.prefix, probeKey)
+      }))
+      return { ok: true, message: '连接成功' }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : '连接失败'
+      return { ok: false, message }
+    }
+  }
+
+  async getUsageStats(): Promise<{ count: number, bytes: number }> {
+    return { count: 0, bytes: 0 }
+  }
+}