@c-time/frelio-cms 1.3.6 → 1.3.7

package/workers/file-upload/src/infra/LoggerSingleton.ts

@@ -0,0 +1,162 @@
+/**
+ * LoggerSingleton - Cloudflare Workers 用のシングルトンログ
+ *
+ * console.log を直接使用せず、このクラスを通してログを出力する。
+ * クリーンアーキテクチャのルールに従い、全レイヤーから使用可能。
+ *
+ * Workers 環境では import.meta.env が使えないため、
+ * 環境変数の判定方法が異なる。
+ */
+
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error'
+
+export type LogEntry = {
+  level: LogLevel
+  timestamp: string
+  context: string
+  message?: string
+  data?: unknown
+  requestId?: string
+}
+
+export type LogHandler = (entry: LogEntry) => void
+
+const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+}
+
+export class LoggerSingleton {
+  private static instance: LoggerSingleton | null = null
+  private minLevel: LogLevel = 'info'
+  private handlers: LogHandler[] = []
+  private requestId: string | null = null
+
+  private constructor() {
+    // Workers ではデフォルトで info レベル
+  }
+
+  static getInstance(): LoggerSingleton {
+    if (!LoggerSingleton.instance) {
+      LoggerSingleton.instance = new LoggerSingleton()
+    }
+    return LoggerSingleton.instance
+  }
+
+  /**
+   * リクエストごとに requestId を設定（トレーシング用）
+   */
+  setRequestId(requestId: string): void {
+    this.requestId = requestId
+  }
+
+  clearRequestId(): void {
+    this.requestId = null
+  }
+
+  setLevel(level: LogLevel): void {
+    this.minLevel = level
+  }
+
+  getLevel(): LogLevel {
+    return this.minLevel
+  }
+
+  addHandler(handler: LogHandler): () => void {
+    this.handlers.push(handler)
+    return () => {
+      const index = this.handlers.indexOf(handler)
+      if (index > -1) {
+        this.handlers.splice(index, 1)
+      }
+    }
+  }
+
+  debug(context: string, messageOrData?: string | unknown, data?: unknown): void {
+    this.log('debug', context, messageOrData, data)
+  }
+
+  info(context: string, messageOrData?: string | unknown, data?: unknown): void {
+    this.log('info', context, messageOrData, data)
+  }
+
+  warn(context: string, messageOrData?: string | unknown, data?: unknown): void {
+    this.log('warn', context, messageOrData, data)
+  }
+
+  error(context: string, messageOrData?: string | unknown, data?: unknown): void {
+    this.log('error', context, messageOrData, data)
+  }
+
+  private log(
+    level: LogLevel,
+    context: string,
+    messageOrData?: string | unknown,
+    data?: unknown
+  ): void {
+    if (!this.shouldLog(level)) return
+
+    const entry: LogEntry = {
+      level,
+      timestamp: new Date().toISOString(),
+      context,
+      message: typeof messageOrData === 'string' ? messageOrData : undefined,
+      data: typeof messageOrData === 'string' ? data : messageOrData,
+      requestId: this.requestId ?? undefined,
+    }
+
+    // Workers 環境では JSON 形式でログ出力（Cloudflare のログ収集と互換性あり）
+    this.logToConsole(entry)
+
+    // カスタムハンドラに通知
+    this.handlers.forEach((handler) => {
+      try {
+        handler(entry)
+      } catch {
+        // ハンドラのエラーは無視
+      }
+    })
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.minLevel]
+  }
+
+  private logToConsole(entry: LogEntry): void {
+    // Cloudflare Workers のログは JSON 形式が推奨
+    const logObject = {
+      level: entry.level,
+      ts: entry.timestamp,
+      ctx: entry.context,
+      ...(entry.message && { msg: entry.message }),
+      ...(entry.data && { data: entry.data }),
+      ...(entry.requestId && { reqId: entry.requestId }),
+    }
+
+    switch (entry.level) {
+      case 'debug':
+        // eslint-disable-next-line no-console
+        console.debug(JSON.stringify(logObject))
+        break
+      case 'info':
+        // eslint-disable-next-line no-console
+        console.info(JSON.stringify(logObject))
+        break
+      case 'warn':
+        // eslint-disable-next-line no-console
+        console.warn(JSON.stringify(logObject))
+        break
+      case 'error':
+        // eslint-disable-next-line no-console
+        console.error(JSON.stringify(logObject))
+        break
+    }
+  }
+}
+
+/**
+ * グローバルログ関数（シングルトンのショートカット）
+ */
+export const logger = LoggerSingleton.getInstance()

package/workers/file-upload/src/presenter/HttpPresenterImpl.ts

@@ -0,0 +1,86 @@
+/**
+ * HttpPresenterImpl - HTTP レスポンスの整形
+ *
+ * UseCase の結果を HTTP Response に変換する。
+ */
+
+export type CorsHeaders = Record<string, string>
+
+export class HttpPresenterImpl {
+  private corsHeaders: CorsHeaders
+
+  constructor(corsHeaders?: CorsHeaders) {
+    this.corsHeaders = corsHeaders ?? {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'GET, POST, PATCH, DELETE, OPTIONS',
+      'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+    }
+  }
+
+  /**
+   * CORS プリフライトレスポンス
+   */
+  cors(): Response {
+    return new Response(null, { headers: this.corsHeaders })
+  }
+
+  /**
+   * 成功レスポンス（200）
+   */
+  ok<T>(data: T): Response {
+    return new Response(JSON.stringify(data), {
+      status: 200,
+      headers: { ...this.corsHeaders, 'Content-Type': 'application/json' },
+    })
+  }
+
+  /**
+   * 作成成功レスポンス（201）
+   */
+  created<T>(data: T): Response {
+    return new Response(JSON.stringify(data), {
+      status: 201,
+      headers: { ...this.corsHeaders, 'Content-Type': 'application/json' },
+    })
+  }
+
+  /**
+   * バリデーションエラー（400）
+   */
+  badRequest(message: string): Response {
+    return new Response(JSON.stringify({ error: message }), {
+      status: 400,
+      headers: { ...this.corsHeaders, 'Content-Type': 'application/json' },
+    })
+  }
+
+  /**
+   * 認証エラー（401）
+   */
+  unauthorized(message = 'Unauthorized'): Response {
+    return new Response(JSON.stringify({ error: message }), {
+      status: 401,
+      headers: { ...this.corsHeaders, 'Content-Type': 'application/json' },
+    })
+  }
+
+  /**
+   * 見つからないエラー（404）
+   */
+  notFound(message = 'Not found'): Response {
+    return new Response(JSON.stringify({ error: message }), {
+      status: 404,
+      headers: { ...this.corsHeaders, 'Content-Type': 'application/json' },
+    })
+  }
+
+  /**
+   * サーバーエラー（500）
+   */
+  serverError(message: string): Response {
+    return new Response(JSON.stringify({ error: message }), {
+      status: 500,
+      headers: { ...this.corsHeaders, 'Content-Type': 'application/json' },
+    })
+  }
+}

package/workers/file-upload/src/repository/AuthRepositoryPort.ts

@@ -0,0 +1,11 @@
+/**
+ * AuthRepositoryPort - トークン検証のインターフェース
+ *
+ * GitHub API への依存を封印し、UseCase 層から分離する。
+ */
+
+import type { GitHubUser } from '../domain/AuthEntity'
+
+export type AuthRepositoryPort = {
+  validateToken(token: string): Promise<GitHubUser | null>
+}

package/workers/file-upload/src/repository/GitHubAuthRepositoryImpl.ts

@@ -0,0 +1,58 @@
+/**
+ * GitHubAuthRepositoryImpl - GitHub API を使ったトークン検証
+ *
+ * Bearer トークンで GitHub /user API を呼び出し、ユーザー情報を取得する。
+ * モジュールレベルの Map でトークンをキャッシュ（TTL 5分）。
+ */
+
+import type { GitHubUser } from '../domain/AuthEntity'
+import type { AuthRepositoryPort } from './AuthRepositoryPort'
+import { logger } from '../infra/LoggerSingleton'
+
+type CacheEntry = {
+  user: GitHubUser
+  expiresAt: number
+}
+
+const tokenCache = new Map<string, CacheEntry>()
+const CACHE_TTL_MS = 5 * 60 * 1000
+
+export class GitHubAuthRepositoryImpl implements AuthRepositoryPort {
+  async validateToken(token: string): Promise<GitHubUser | null> {
+    const cached = tokenCache.get(token)
+    if (cached && cached.expiresAt > Date.now()) {
+      return cached.user
+    }
+
+    try {
+      const res = await fetch('https://api.github.com/user', {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          Accept: 'application/vnd.github.v3+json',
+          'User-Agent': 'frelio-file-upload',
+        },
+      })
+
+      if (!res.ok) {
+        logger.warn('GitHubAuthRepositoryImpl.validateToken', {
+          status: res.status,
+        })
+        tokenCache.delete(token)
+        return null
+      }
+
+      const data = (await res.json()) as { login: string }
+      const user: GitHubUser = { login: data.login }
+
+      tokenCache.set(token, {
+        user,
+        expiresAt: Date.now() + CACHE_TTL_MS,
+      })
+
+      return user
+    } catch (error) {
+      logger.error('GitHubAuthRepositoryImpl.validateToken', { error })
+      return null
+    }
+  }
+}

package/workers/file-upload/src/repository/R2RepositoryImpl.ts

@@ -0,0 +1,145 @@
+/**
+ * R2RepositoryImpl - R2 ストレージ操作の実装
+ *
+ * Cloudflare R2 バケットへのアクセスを封印する。
+ */
+
+import { createEmptyYearFiles, type YearFiles } from '../domain/FileEntity'
+import { logger } from '../infra/LoggerSingleton'
+import type { R2ObjectInfo, R2RepositoryPort, UploadFileParams } from './R2RepositoryPort'
+
+export class R2RepositoryImpl implements R2RepositoryPort {
+  constructor(
+    private bucket: R2Bucket,
+    private publicUrl: string
+  ) {}
+
+  async upload(params: UploadFileParams): Promise<void> {
+    logger.debug('R2RepositoryImpl.upload', { key: params.key })
+    await this.bucket.put(params.key, params.content, {
+      httpMetadata: {
+        contentType: params.contentType,
+      },
+      customMetadata: params.customMetadata,
+    })
+  }
+
+  async delete(key: string): Promise<void> {
+    logger.debug('R2RepositoryImpl.delete', { key })
+    await this.bucket.delete(key)
+  }
+
+  async deleteMany(keys: string[]): Promise<void> {
+    logger.debug('R2RepositoryImpl.deleteMany', { count: keys.length })
+    await Promise.all(keys.map((key) => this.bucket.delete(key)))
+  }
+
+  async head(key: string): Promise<R2ObjectInfo | null> {
+    const obj = await this.bucket.head(key)
+    if (!obj) return null
+    return this.toObjectInfo(obj)
+  }
+
+  async get(key: string): Promise<{ body: ReadableStream; info: R2ObjectInfo } | null> {
+    const obj = await this.bucket.get(key)
+    if (!obj) return null
+    return {
+      body: obj.body,
+      info: this.toObjectInfo(obj),
+    }
+  }
+
+  async list(prefix: string): Promise<R2ObjectInfo[]> {
+    const result: R2ObjectInfo[] = []
+    let cursor: string | undefined
+
+    do {
+      const listed = await this.bucket.list({
+        prefix,
+        cursor,
+        include: ['httpMetadata', 'customMetadata'],
+      } as R2ListOptions)
+
+      for (const obj of listed.objects) {
+        result.push(this.toObjectInfo(obj))
+      }
+
+      cursor = listed.truncated ? listed.cursor : undefined
+    } while (cursor)
+
+    return result
+  }
+
+  async listAll(): Promise<R2ObjectInfo[]> {
+    const result: R2ObjectInfo[] = []
+    let cursor: string | undefined
+
+    do {
+      const listed = await this.bucket.list({
+        cursor,
+        include: ['httpMetadata', 'customMetadata'],
+      } as R2ListOptions)
+
+      for (const obj of listed.objects) {
+        result.push(this.toObjectInfo(obj))
+      }
+
+      cursor = listed.truncated ? listed.cursor : undefined
+    } while (cursor)
+
+    return result
+  }
+
+  async readYearFiles(year: number): Promise<YearFiles> {
+    const key = `${year}/files.json`
+    const obj = await this.bucket.get(key)
+    if (!obj) {
+      return createEmptyYearFiles(year)
+    }
+    return JSON.parse(await obj.text())
+  }
+
+  async writeYearFiles(year: number, data: YearFiles): Promise<void> {
+    const key = `${year}/files.json`
+    logger.debug('R2RepositoryImpl.writeYearFiles', { year, fileCount: data.files.length })
+    await this.bucket.put(key, JSON.stringify(data, null, 2), {
+      httpMetadata: { contentType: 'application/json' },
+    })
+  }
+
+  async getAvailableYears(): Promise<number[]> {
+    const years = new Set<number>()
+    const objects = await this.listAll()
+
+    for (const obj of objects) {
+      const match = obj.key.match(/^(\d{4})\//)
+      if (match) {
+        years.add(parseInt(match[1]))
+      }
+    }
+
+    return Array.from(years).sort((a, b) => b - a) // 降順
+  }
+
+  getCurrentYear(): number {
+    return new Date().getFullYear()
+  }
+
+  getBaseUrl(): string {
+    return this.publicUrl
+  }
+
+  private toObjectInfo(obj: R2Object | R2ObjectBody): R2ObjectInfo {
+    return {
+      key: obj.key,
+      size: obj.size,
+      uploaded: obj.uploaded,
+      httpMetadata: obj.httpMetadata
+        ? {
+            contentType: obj.httpMetadata.contentType,
+          }
+        : undefined,
+      customMetadata: obj.customMetadata,
+    }
+  }
+}

package/workers/file-upload/src/repository/R2RepositoryPort.ts

@@ -0,0 +1,86 @@
+/**
+ * R2RepositoryPort - R2 ストレージ操作のインターフェース
+ *
+ * R2 への依存を封印し、UseCase 層から分離する。
+ */
+
+import type { FileEntry, YearFiles } from '../domain/FileEntity'
+
+export type UploadFileParams = {
+  key: string
+  content: ReadableStream
+  contentType: string
+  customMetadata?: Record<string, string>
+}
+
+export type R2ObjectInfo = {
+  key: string
+  size: number
+  uploaded: Date
+  httpMetadata?: {
+    contentType?: string
+  }
+  customMetadata?: Record<string, string>
+}
+
+export interface R2RepositoryPort {
+  /**
+   * ファイルをアップロード
+   */
+  upload(params: UploadFileParams): Promise<void>
+
+  /**
+   * ファイルを削除
+   */
+  delete(key: string): Promise<void>
+
+  /**
+   * 複数ファイルを削除
+   */
+  deleteMany(keys: string[]): Promise<void>
+
+  /**
+   * ファイルのメタデータを取得
+   */
+  head(key: string): Promise<R2ObjectInfo | null>
+
+  /**
+   * ファイルの内容を取得
+   */
+  get(key: string): Promise<{ body: ReadableStream; info: R2ObjectInfo } | null>
+
+  /**
+   * プレフィックスでファイル一覧を取得
+   */
+  list(prefix: string): Promise<R2ObjectInfo[]>
+
+  /**
+   * 全ファイル一覧を取得（ページネーション対応）
+   */
+  listAll(): Promise<R2ObjectInfo[]>
+
+  /**
+   * 年別インデックスファイル（files.json）を読み込み
+   */
+  readYearFiles(year: number): Promise<YearFiles>
+
+  /**
+   * 年別インデックスファイル（files.json）を書き込み
+   */
+  writeYearFiles(year: number, data: YearFiles): Promise<void>
+
+  /**
+   * 利用可能な年一覧を取得
+   */
+  getAvailableYears(): Promise<number[]>
+
+  /**
+   * 現在の年を取得
+   */
+  getCurrentYear(): number
+
+  /**
+   * ストレージのベース URL を取得
+   */
+  getBaseUrl(): string
+}

package/workers/file-upload/src/usecase/DeleteFileUseCase.ts

@@ -0,0 +1,97 @@
+/**
+ * DeleteFileUseCase - ファイルの削除
+ */
+
+import { recalculateYearFilesStats } from '../domain/FileEntity'
+import { logger } from '../infra/LoggerSingleton'
+import type { R2RepositoryPort } from '../repository/R2RepositoryPort'
+
+export type DeleteFileParams = {
+  uuid: string
+  year?: number
+}
+
+export type DeleteFileResult = {
+  success: boolean
+  uuid: string
+}
+
+export class DeleteFileUseCase {
+  constructor(private r2Repository: R2RepositoryPort) {}
+
+  async execute(params: DeleteFileParams): Promise<DeleteFileResult> {
+    logger.info('DeleteFileUseCase.execute', params)
+
+    // 年が指定されている場合: 新形式
+    if (params.year) {
+      const deleted = await this.deleteFromYear(params.uuid, params.year)
+      if (deleted) {
+        return { success: true, uuid: params.uuid }
+      }
+    }
+
+    // 年が指定されていない場合: 旧形式（後方互換）
+    const deleted = await this.deleteOldFormat(params.uuid)
+    if (deleted) {
+      return { success: true, uuid: params.uuid }
+    }
+
+    logger.warn('DeleteFileUseCase.execute', 'File not found', { uuid: params.uuid })
+    throw new Error('File not found')
+  }
+
+  private async deleteFromYear(uuid: string, year: number): Promise<boolean> {
+    // 画像セット形式: {year}/{uuid}/
+    const setObjects = await this.r2Repository.list(`${year}/${uuid}/`)
+    if (setObjects.length > 0) {
+      await this.r2Repository.deleteMany(setObjects.map((o) => o.key))
+      await this.removeFromYearFiles(uuid, year)
+      logger.debug('DeleteFileUseCase', 'Deleted image set', { uuid, year })
+      return true
+    }
+
+    // 単一ファイル形式: {year}/{uuid}.ext
+    const singleObjects = await this.r2Repository.list(`${year}/${uuid}`)
+    for (const obj of singleObjects) {
+      if (obj.key.startsWith(`${year}/${uuid}.`) || obj.key === `${year}/${uuid}`) {
+        await this.r2Repository.delete(obj.key)
+        await this.removeFromYearFiles(uuid, year)
+        logger.debug('DeleteFileUseCase', 'Deleted single file', { uuid, year })
+        return true
+      }
+    }
+
+    return false
+  }
+
+  private async deleteOldFormat(uuid: string): Promise<boolean> {
+    // 旧形式の画像セット: {uuid}/
+    const setObjects = await this.r2Repository.list(`${uuid}/`)
+    if (setObjects.length > 0) {
+      await this.r2Repository.deleteMany(setObjects.map((o) => o.key))
+      logger.debug('DeleteFileUseCase', 'Deleted old format image set', { uuid })
+      return true
+    }
+
+    // 旧形式の単一ファイル: {uuid}.ext
+    const extensions = ['', '.jpg', '.jpeg', '.png', '.gif', '.webp', '.svg', '.pdf']
+    for (const ext of extensions) {
+      const key = uuid + ext
+      const obj = await this.r2Repository.head(key)
+      if (obj) {
+        await this.r2Repository.delete(key)
+        logger.debug('DeleteFileUseCase', 'Deleted old format single file', { uuid, key })
+        return true
+      }
+    }
+
+    return false
+  }
+
+  private async removeFromYearFiles(uuid: string, year: number): Promise<void> {
+    const yearFiles = await this.r2Repository.readYearFiles(year)
+    yearFiles.files = yearFiles.files.filter((f) => f.uuid !== uuid)
+    const updatedYearFiles = recalculateYearFilesStats(yearFiles)
+    await this.r2Repository.writeYearFiles(year, updatedYearFiles)
+  }
+}

package/workers/file-upload/src/usecase/GetFileUseCase.ts

@@ -0,0 +1,50 @@
+/**
+ * GetFileUseCase - ファイル情報の取得
+ */
+
+import { logger } from '../infra/LoggerSingleton'
+import type { R2RepositoryPort } from '../repository/R2RepositoryPort'
+
+export type GetFileParams = {
+  uuid: string
+}
+
+export type GetFileResult = {
+  uuid: string
+  key: string
+  url: string
+  size: number
+  mimeType?: string
+  originalName?: string
+  uploadedBy?: string
+}
+
+export class GetFileUseCase {
+  constructor(private r2Repository: R2RepositoryPort) {}
+
+  async execute(params: GetFileParams): Promise<GetFileResult> {
+    logger.debug('GetFileUseCase.execute', { uuid: params.uuid })
+
+    // 拡張子なしと一般的な拡張子で試行
+    const extensions = ['', '.jpg', '.jpeg', '.png', '.gif', '.webp', '.svg', '.pdf']
+
+    for (const ext of extensions) {
+      const key = params.uuid + ext
+      const obj = await this.r2Repository.head(key)
+      if (obj) {
+        return {
+          uuid: params.uuid,
+          key,
+          url: key,
+          size: obj.size,
+          mimeType: obj.httpMetadata?.contentType,
+          originalName: obj.customMetadata?.originalName,
+          uploadedBy: obj.customMetadata?.uploadedBy,
+        }
+      }
+    }
+
+    logger.warn('GetFileUseCase.execute', 'File not found', { uuid: params.uuid })
+    throw new Error('File not found')
+  }
+}