@c-time/frelio-cms 1.3.5 → 1.3.7

package/workers/file-upload/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@frelio/file-upload",
+  "version": "0.0.1",
+  "private": true,
+  "scripts": {
+    "dev": "wrangler dev",
+    "deploy": "wrangler deploy"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20240208.0",
+    "typescript": "^5.3.3",
+    "wrangler": "^3.28.0"
+  }
+}

package/workers/file-upload/src/controller/DIContainer.ts

@@ -0,0 +1,103 @@
+/**
+ * DIContainer - Cloudflare Workers 用の依存性注入コンテナ
+ *
+ * Workers 環境では Env オブジェクトを受け取り、
+ * R2 バケットなどの Cloudflare バインディングを Repository に注入する。
+ */
+
+import { LoggerSingleton } from '../infra/LoggerSingleton'
+
+type Factory<T> = () => T
+type ServiceKey = string
+
+export class DIContainer {
+  private singletons = new Map<ServiceKey, unknown>()
+  private factories = new Map<ServiceKey, Factory<unknown>>()
+
+  constructor() {
+    // Logger はデフォルトで登録
+    this.registerSingleton('Logger', LoggerSingleton.getInstance())
+  }
+
+  /**
+   * シングルトンとしてインスタンスを登録
+   */
+  registerSingleton<T>(key: ServiceKey, instance: T): void {
+    this.singletons.set(key, instance)
+  }
+
+  /**
+   * ファクトリ関数を登録（毎回新しいインスタンスを生成）
+   */
+  registerFactory<T>(key: ServiceKey, factory: Factory<T>): void {
+    this.factories.set(key, factory)
+  }
+
+  /**
+   * 登録済みのサービスを取得
+   */
+  get<T>(key: ServiceKey): T {
+    // シングルトンを優先
+    if (this.singletons.has(key)) {
+      return this.singletons.get(key) as T
+    }
+
+    // ファクトリがあれば新しいインスタンスを生成
+    if (this.factories.has(key)) {
+      const factory = this.factories.get(key) as Factory<T>
+      return factory()
+    }
+
+    throw new Error(`DIContainer: Service '${key}' is not registered`)
+  }
+
+  /**
+   * サービスが登録済みかどうか
+   */
+  has(key: ServiceKey): boolean {
+    return this.singletons.has(key) || this.factories.has(key)
+  }
+
+  /**
+   * Logger のショートカット
+   */
+  getLogger(): LoggerSingleton {
+    return this.get<LoggerSingleton>('Logger')
+  }
+}
+
+/**
+ * リクエストごとにコンテナを作成
+ *
+ * Workers ではリクエストごとに Env オブジェクトが渡されるため、
+ * グローバルシングルトンではなくリクエストスコープで管理する。
+ */
+export function createContainer(env: Env): DIContainer {
+  const container = new DIContainer()
+  const logger = container.getLogger()
+
+  // Env オブジェクトを登録（R2 バケットなどへのアクセスに使用）
+  container.registerSingleton('Env', env)
+
+  // TODO: Phase 2 で Repository を登録
+  // container.registerSingleton('R2Repository', new R2RepositoryImpl(env.FILES_BUCKET, logger))
+
+  // TODO: Phase 2 で UseCase を登録
+  // container.registerFactory('UploadFileUseCase', () => new UploadFileUseCase(...))
+
+  logger.debug('DIContainer', 'Container created for request')
+
+  return container
+}
+
+/**
+ * Cloudflare Workers の Env 型定義
+ *
+ * wrangler.toml で定義されたバインディングに対応
+ */
+interface Env {
+  FILES_BUCKET: R2Bucket
+  GITHUB_TOKEN?: string
+  CONTENT_REPO?: string
+  ALLOWED_ORIGINS?: string
+}

package/workers/file-upload/src/controller/FileController.ts

@@ -0,0 +1,248 @@
+/**
+ * FileController - ファイル操作のコントローラ
+ *
+ * HTTP リクエストを受け取り、適切な UseCase を実行し、
+ * Presenter でレスポンスを整形して返す。
+ */
+
+import type { PresetName } from '../domain/FileEntity'
+import { logger } from '../infra/LoggerSingleton'
+import { HttpPresenterImpl, type CorsHeaders } from '../presenter/HttpPresenterImpl'
+import type { R2RepositoryPort } from '../repository/R2RepositoryPort'
+import { DeleteFileUseCase } from '../usecase/DeleteFileUseCase'
+import { GetFileUseCase } from '../usecase/GetFileUseCase'
+import { ListFilesUseCase } from '../usecase/ListFilesUseCase'
+import { RebuildIndexUseCase } from '../usecase/RebuildIndexUseCase'
+import { UpdateFileMetadataUseCase } from '../usecase/UpdateFileMetadataUseCase'
+import { UploadFileUseCase } from '../usecase/UploadFileUseCase'
+import { UploadImageSetUseCase } from '../usecase/UploadImageSetUseCase'
+
+type ExecutionContext = {
+  waitUntil(promise: Promise<unknown>): void
+}
+
+export class FileController {
+  private presenter: HttpPresenterImpl
+  private uploadFileUseCase: UploadFileUseCase
+  private uploadImageSetUseCase: UploadImageSetUseCase
+  private deleteFileUseCase: DeleteFileUseCase
+  private listFilesUseCase: ListFilesUseCase
+  private getFileUseCase: GetFileUseCase
+  private updateFileMetadataUseCase: UpdateFileMetadataUseCase
+  private rebuildIndexUseCase: RebuildIndexUseCase
+
+  constructor(r2Repository: R2RepositoryPort, corsHeaders?: CorsHeaders) {
+    this.presenter = new HttpPresenterImpl(corsHeaders)
+    this.uploadFileUseCase = new UploadFileUseCase(r2Repository)
+    this.uploadImageSetUseCase = new UploadImageSetUseCase(r2Repository)
+    this.deleteFileUseCase = new DeleteFileUseCase(r2Repository)
+    this.listFilesUseCase = new ListFilesUseCase(r2Repository)
+    this.getFileUseCase = new GetFileUseCase(r2Repository)
+    this.updateFileMetadataUseCase = new UpdateFileMetadataUseCase(r2Repository)
+    this.rebuildIndexUseCase = new RebuildIndexUseCase(r2Repository)
+  }
+
+  /**
+   * CORS プリフライト
+   */
+  handleCors(): Response {
+    return this.presenter.cors()
+  }
+
+  /**
+   * POST /upload - 単一ファイルのアップロード
+   */
+  async handleUpload(request: Request): Promise<Response> {
+    const formData = await request.formData()
+    const file = formData.get('file') as File | null
+    const uploadedBy = formData.get('uploadedBy') as string | null
+
+    if (!file) {
+      return this.presenter.badRequest('No file provided')
+    }
+    if (!uploadedBy) {
+      return this.presenter.badRequest('uploadedBy is required')
+    }
+
+    try {
+      const result = await this.uploadFileUseCase.execute({ file, uploadedBy })
+      return this.presenter.created(result)
+    } catch (error) {
+      logger.error('FileController.handleUpload', { error })
+      return this.presenter.serverError((error as Error).message)
+    }
+  }
+
+  /**
+   * POST /upload-set - 画像セットのアップロード
+   */
+  async handleUploadSet(request: Request, ctx: ExecutionContext): Promise<Response> {
+    const formData = await request.formData()
+    const uploadedBy = formData.get('uploadedBy') as string | null
+    const originalName = formData.get('originalName') as string | null
+
+    if (!uploadedBy) {
+      return this.presenter.badRequest('uploadedBy is required')
+    }
+    if (!originalName) {
+      return this.presenter.badRequest('originalName is required')
+    }
+
+    // プリセットファイルを収集
+    const files = new Map<PresetName, File>()
+    const presetNames: PresetName[] = ['original', 'retina', 'large', 'medium', 'small', 'thumbnail']
+    for (const name of presetNames) {
+      const file = formData.get(name) as File | null
+      if (file) {
+        files.set(name, file)
+      }
+    }
+
+    if (files.size === 0) {
+      return this.presenter.badRequest('No image files provided')
+    }
+
+    const widthStr = formData.get('width') as string | null
+    const heightStr = formData.get('height') as string | null
+    const width = widthStr ? parseInt(widthStr) : undefined
+    const height = heightStr ? parseInt(heightStr) : undefined
+
+    try {
+      const result = await this.uploadImageSetUseCase.execute({ originalName, uploadedBy, files, width, height })
+
+      // プリウォーム（バックグラウンド）
+      const prewarmUrls = this.uploadImageSetUseCase.getPrewarmUrls(result.variants)
+      ctx.waitUntil(this.prewarmUrls(prewarmUrls))
+
+      return this.presenter.created(result)
+    } catch (error) {
+      logger.error('FileController.handleUploadSet', { error })
+      return this.presenter.serverError((error as Error).message)
+    }
+  }
+
+  /**
+   * GET /years - 利用可能な年一覧
+   */
+  async handleGetYears(): Promise<Response> {
+    try {
+      const result = await this.listFilesUseCase.getAvailableYears()
+      return this.presenter.ok(result)
+    } catch (error) {
+      logger.error('FileController.handleGetYears', { error })
+      return this.presenter.serverError((error as Error).message)
+    }
+  }
+
+  /**
+   * GET /list - ファイル一覧
+   */
+  async handleListFiles(url: URL): Promise<Response> {
+    const yearParam = url.searchParams.get('year')
+    const year = yearParam ? parseInt(yearParam) : undefined
+
+    try {
+      const result = await this.listFilesUseCase.execute({ year })
+      return this.presenter.ok(result)
+    } catch (error) {
+      logger.error('FileController.handleListFiles', { error })
+      return this.presenter.serverError((error as Error).message)
+    }
+  }
+
+  /**
+   * GET /files/:uuid - ファイル情報
+   */
+  async handleGetFile(uuid: string): Promise<Response> {
+    try {
+      const result = await this.getFileUseCase.execute({ uuid })
+      return this.presenter.ok(result)
+    } catch (error) {
+      if ((error as Error).message === 'File not found') {
+        return this.presenter.notFound('File not found')
+      }
+      logger.error('FileController.handleGetFile', { error })
+      return this.presenter.serverError((error as Error).message)
+    }
+  }
+
+  /**
+   * PATCH /files/:uuid - メタデータ更新
+   */
+  async handleUpdateFileMetadata(uuid: string, request: Request): Promise<Response> {
+    const body = (await request.json()) as { year?: number; alt?: string }
+    const { year, alt } = body
+
+    if (year === undefined) {
+      return this.presenter.badRequest('year is required')
+    }
+
+    try {
+      const result = await this.updateFileMetadataUseCase.execute({ uuid, year, alt })
+      return this.presenter.ok(result)
+    } catch (error) {
+      if ((error as Error).message === 'File not found') {
+        return this.presenter.notFound('File not found')
+      }
+      logger.error('FileController.handleUpdateFileMetadata', { error })
+      return this.presenter.serverError((error as Error).message)
+    }
+  }
+
+  /**
+   * DELETE /files/:uuid - ファイル削除
+   */
+  async handleDeleteFile(uuid: string, url: URL): Promise<Response> {
+    const yearParam = url.searchParams.get('year')
+    const year = yearParam ? parseInt(yearParam) : undefined
+
+    try {
+      const result = await this.deleteFileUseCase.execute({ uuid, year })
+      return this.presenter.ok(result)
+    } catch (error) {
+      if ((error as Error).message === 'File not found') {
+        return this.presenter.notFound('File not found')
+      }
+      logger.error('FileController.handleDeleteFile', { error })
+      return this.presenter.serverError((error as Error).message)
+    }
+  }
+
+  /**
+   * POST /rebuild/:year - インデックス再構築
+   */
+  async handleRebuildIndex(year: number): Promise<Response> {
+    try {
+      const result = await this.rebuildIndexUseCase.execute({ year })
+      return this.presenter.ok(result)
+    } catch (error) {
+      logger.error('FileController.handleRebuildIndex', { error })
+      return this.presenter.serverError((error as Error).message)
+    }
+  }
+
+  /**
+   * Not Found
+   */
+  handleNotFound(): Response {
+    return this.presenter.notFound()
+  }
+
+  /**
+   * プリウォーム: CDN キャッシュを温める
+   */
+  private async prewarmUrls(urls: string[]): Promise<void> {
+    const results = await Promise.allSettled(
+      urls.map((url) =>
+        fetch(url, {
+          method: 'HEAD',
+          cf: { cacheTtl: 86400 },
+        })
+      )
+    )
+    logger.debug(
+      'FileController.prewarmUrls',
+      `Completed: ${results.filter((r) => r.status === 'fulfilled').length}/${urls.length}`
+    )
+  }
+}

package/workers/file-upload/src/domain/AuthEntity.ts

@@ -0,0 +1,17 @@
+/**
+ * AuthEntity - 認証関連の型定義
+ */
+
+export type GitHubUser = {
+  login: string
+}
+
+export class AuthError extends Error {
+  constructor(
+    message: string,
+    public statusCode: number,
+  ) {
+    super(message)
+    this.name = 'AuthError'
+  }
+}

package/workers/file-upload/src/domain/FileEntity.ts

@@ -0,0 +1,113 @@
+/**
+ * FileEntity - ファイルのエンティティ
+ *
+ * R2 に保存されるファイルのビジネスオブジェクト。
+ * 単一ファイルと画像セット（複数プリセット）の両方を表現する。
+ */
+
+export type FileEntry = {
+  uuid: string
+  originalName: string
+  contentType: string
+  size: number
+  uploadedBy: string
+  uploadedAt: string
+  url: string
+  alt?: string
+  width?: number
+  height?: number
+  variants?: Record<string, string>
+}
+
+export type YearFiles = {
+  year: number
+  updatedAt: string
+  totalCount: number
+  totalSize: number
+  files: FileEntry[]
+}
+
+export type FileMetadata = {
+  uuid: string
+  originalName: string
+  mimeType: string
+  size: number
+  width?: number
+  height?: number
+  uploadedBy: string
+  createdAt: string
+}
+
+/**
+ * プリセット名の定数
+ */
+export const PRESET_NAMES = ['original', 'retina', 'large', 'medium', 'small', 'thumbnail'] as const
+export type PresetName = (typeof PRESET_NAMES)[number]
+
+/**
+ * ファイルエントリを作成
+ */
+export function createFileEntry(params: {
+  uuid: string
+  originalName: string
+  contentType: string
+  size: number
+  uploadedBy: string
+  uploadedAt: string
+  publicUrl: string
+  width?: number
+  height?: number
+  variants?: Record<string, string>
+}): FileEntry {
+  return {
+    uuid: params.uuid,
+    originalName: params.originalName,
+    contentType: params.contentType,
+    size: params.size,
+    uploadedBy: params.uploadedBy,
+    uploadedAt: params.uploadedAt,
+    url: params.publicUrl,
+    ...(params.width != null && { width: params.width }),
+    ...(params.height != null && { height: params.height }),
+    ...(params.variants && { variants: params.variants }),
+  }
+}
+
+/**
+ * 画像セットからサムネイル URL を選択
+ */
+export function selectThumbnailUrl(variants: Record<string, string>): string {
+  return (
+    variants.thumbnail ||
+    variants.small ||
+    variants.medium ||
+    variants.large ||
+    variants.original ||
+    ''
+  )
+}
+
+/**
+ * YearFiles の統計を再計算
+ */
+export function recalculateYearFilesStats(yearFiles: YearFiles): YearFiles {
+  return {
+    ...yearFiles,
+    totalCount: yearFiles.files.length,
+    totalSize: yearFiles.files.reduce((sum, f) => sum + f.size, 0),
+    updatedAt: new Date().toISOString(),
+  }
+}
+
+/**
+ * 空の YearFiles を作成
+ */
+export function createEmptyYearFiles(year: number): YearFiles {
+  return {
+    year,
+    updatedAt: new Date().toISOString(),
+    totalCount: 0,
+    totalSize: 0,
+    files: [],
+  }
+}

package/workers/file-upload/src/index.ts

@@ -0,0 +1,134 @@
+/**
+ * Cloudflare Workers エントリポイント
+ *
+ * クリーンアーキテクチャに従い、薄いルーターとして機能する。
+ * ビジネスロジックは UseCase 層に、HTTP 処理は Controller 層に委譲。
+ */
+
+import { FileController } from './controller/FileController'
+import { AuthError } from './domain/AuthEntity'
+import { logger } from './infra/LoggerSingleton'
+import { HttpPresenterImpl } from './presenter/HttpPresenterImpl'
+import { GitHubAuthRepositoryImpl } from './repository/GitHubAuthRepositoryImpl'
+import { R2RepositoryImpl } from './repository/R2RepositoryImpl'
+import { ValidateAuthUseCase } from './usecase/ValidateAuthUseCase'
+
+export interface Env {
+  R2: R2Bucket
+  R2_PUBLIC_URL: string
+  ALLOWED_ORIGINS?: string
+}
+
+type ExecutionContext = {
+  waitUntil(promise: Promise<unknown>): void
+  passThroughOnException(): void
+}
+
+export default {
+  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
+    const url = new URL(request.url)
+
+    // リクエスト ID を設定（トレーシング用）
+    const requestId = crypto.randomUUID().slice(0, 8)
+    logger.setRequestId(requestId)
+
+    try {
+      // CORS: リクエストの Origin を許可リストと照合
+      const origin = request.headers.get('Origin') ?? ''
+      const allowedOrigins = env.ALLOWED_ORIGINS?.split(',').map((s) => s.trim()) ?? []
+      const matchedOrigin = allowedOrigins.includes(origin) ? origin : null
+      const corsHeaders = {
+        'Access-Control-Allow-Origin': matchedOrigin ?? '',
+        'Access-Control-Allow-Methods': 'GET, POST, PATCH, DELETE, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+        Vary: 'Origin',
+      }
+
+      // DI: Repository と Controller を初期化
+      const r2Repository = new R2RepositoryImpl(env.R2, env.R2_PUBLIC_URL)
+      const controller = new FileController(r2Repository, corsHeaders)
+
+      // CORS プリフライト
+      if (request.method === 'OPTIONS') {
+        return controller.handleCors()
+      }
+
+      // 認証: Bearer トークンを検証
+      const authRepository = new GitHubAuthRepositoryImpl()
+      const validateAuth = new ValidateAuthUseCase(authRepository)
+      const presenter = new HttpPresenterImpl(corsHeaders)
+      try {
+        await validateAuth.execute(request.headers.get('Authorization'))
+      } catch (error) {
+        if (error instanceof AuthError) {
+          return presenter.unauthorized(error.message)
+        }
+        throw error
+      }
+
+      // ルーティング
+      // POST /upload
+      if (request.method === 'POST' && url.pathname === '/upload') {
+        return await controller.handleUpload(request)
+      }
+
+      // POST /upload-set
+      if (request.method === 'POST' && url.pathname === '/upload-set') {
+        return await controller.handleUploadSet(request, ctx)
+      }
+
+      // GET /years
+      if (request.method === 'GET' && url.pathname === '/years') {
+        return await controller.handleGetYears()
+      }
+
+      // GET /list
+      if (request.method === 'GET' && url.pathname === '/list') {
+        return await controller.handleListFiles(url)
+      }
+
+      // GET /files/:uuid
+      if (request.method === 'GET' && url.pathname.startsWith('/files/')) {
+        const uuid = url.pathname.replace('/files/', '')
+        return await controller.handleGetFile(uuid)
+      }
+
+      // PATCH /files/:uuid
+      if (request.method === 'PATCH' && url.pathname.startsWith('/files/')) {
+        const uuid = url.pathname.replace('/files/', '')
+        return await controller.handleUpdateFileMetadata(uuid, request)
+      }
+
+      // DELETE /files/:uuid
+      if (request.method === 'DELETE' && url.pathname.startsWith('/files/')) {
+        const uuid = url.pathname.replace('/files/', '')
+        return await controller.handleDeleteFile(uuid, url)
+      }
+
+      // POST /rebuild/:year
+      const rebuildMatch = url.pathname.match(/^\/rebuild\/(\d{4})$/)
+      if (request.method === 'POST' && rebuildMatch) {
+        const year = parseInt(rebuildMatch[1])
+        return await controller.handleRebuildIndex(year)
+      }
+
+      // Not Found
+      return controller.handleNotFound()
+    } catch (error) {
+      logger.error('Worker.fetch', 'Unhandled error', { error })
+      const origin = request.headers.get('Origin') ?? ''
+      const allowedOrigins = env.ALLOWED_ORIGINS?.split(',').map((s) => s.trim()) ?? []
+      const matchedOrigin = allowedOrigins.includes(origin) ? origin : ''
+      return new Response(JSON.stringify({ error: (error as Error).message }), {
+        status: 500,
+        headers: {
+          'Access-Control-Allow-Origin': matchedOrigin,
+          'Content-Type': 'application/json',
+          Vary: 'Origin',
+        },
+      })
+    } finally {
+      logger.clearRequestId()
+    }
+  },
+}