@c-time/frelio-cms 1.3.7 → 1.3.8

package/functions/api/storage/_middleware.js

@@ -0,0 +1,1012 @@
+// ../../workers/file-upload/src/infra/LoggerSingleton.ts
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var LoggerSingleton = class _LoggerSingleton {
+  static instance = null;
+  minLevel = "info";
+  handlers = [];
+  requestId = null;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_LoggerSingleton.instance) {
+      _LoggerSingleton.instance = new _LoggerSingleton();
+    }
+    return _LoggerSingleton.instance;
+  }
+  /**
+   * リクエストごとに requestId を設定（トレーシング用）
+   */
+  setRequestId(requestId) {
+    this.requestId = requestId;
+  }
+  clearRequestId() {
+    this.requestId = null;
+  }
+  setLevel(level) {
+    this.minLevel = level;
+  }
+  getLevel() {
+    return this.minLevel;
+  }
+  addHandler(handler) {
+    this.handlers.push(handler);
+    return () => {
+      const index = this.handlers.indexOf(handler);
+      if (index > -1) {
+        this.handlers.splice(index, 1);
+      }
+    };
+  }
+  debug(context, messageOrData, data) {
+    this.log("debug", context, messageOrData, data);
+  }
+  info(context, messageOrData, data) {
+    this.log("info", context, messageOrData, data);
+  }
+  warn(context, messageOrData, data) {
+    this.log("warn", context, messageOrData, data);
+  }
+  error(context, messageOrData, data) {
+    this.log("error", context, messageOrData, data);
+  }
+  log(level, context, messageOrData, data) {
+    if (!this.shouldLog(level)) return;
+    const entry = {
+      level,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      context,
+      message: typeof messageOrData === "string" ? messageOrData : void 0,
+      data: typeof messageOrData === "string" ? data : messageOrData,
+      requestId: this.requestId ?? void 0
+    };
+    this.logToConsole(entry);
+    this.handlers.forEach((handler) => {
+      try {
+        handler(entry);
+      } catch {
+      }
+    });
+  }
+  shouldLog(level) {
+    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.minLevel];
+  }
+  logToConsole(entry) {
+    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":
+        console.debug(JSON.stringify(logObject));
+        break;
+      case "info":
+        console.info(JSON.stringify(logObject));
+        break;
+      case "warn":
+        console.warn(JSON.stringify(logObject));
+        break;
+      case "error":
+        console.error(JSON.stringify(logObject));
+        break;
+    }
+  }
+};
+var logger = LoggerSingleton.getInstance();
+
+// ../../workers/file-upload/src/presenter/HttpPresenterImpl.ts
+var HttpPresenterImpl = class {
+  corsHeaders;
+  constructor(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() {
+    return new Response(null, { headers: this.corsHeaders });
+  }
+  /**
+   * 成功レスポンス（200）
+   */
+  ok(data) {
+    return new Response(JSON.stringify(data), {
+      status: 200,
+      headers: { ...this.corsHeaders, "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * 作成成功レスポンス（201）
+   */
+  created(data) {
+    return new Response(JSON.stringify(data), {
+      status: 201,
+      headers: { ...this.corsHeaders, "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * バリデーションエラー（400）
+   */
+  badRequest(message) {
+    return new Response(JSON.stringify({ error: message }), {
+      status: 400,
+      headers: { ...this.corsHeaders, "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * 認証エラー（401）
+   */
+  unauthorized(message = "Unauthorized") {
+    return new Response(JSON.stringify({ error: message }), {
+      status: 401,
+      headers: { ...this.corsHeaders, "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * 見つからないエラー（404）
+   */
+  notFound(message = "Not found") {
+    return new Response(JSON.stringify({ error: message }), {
+      status: 404,
+      headers: { ...this.corsHeaders, "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * サーバーエラー（500）
+   */
+  serverError(message) {
+    return new Response(JSON.stringify({ error: message }), {
+      status: 500,
+      headers: { ...this.corsHeaders, "Content-Type": "application/json" }
+    });
+  }
+};
+
+// ../../workers/file-upload/src/domain/FileEntity.ts
+var PRESET_NAMES = ["original", "retina", "large", "medium", "small", "thumbnail"];
+function createFileEntry(params) {
+  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 }
+  };
+}
+function selectThumbnailUrl(variants) {
+  return variants.thumbnail || variants.small || variants.medium || variants.large || variants.original || "";
+}
+function recalculateYearFilesStats(yearFiles) {
+  return {
+    ...yearFiles,
+    totalCount: yearFiles.files.length,
+    totalSize: yearFiles.files.reduce((sum, f) => sum + f.size, 0),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createEmptyYearFiles(year) {
+  return {
+    year,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalCount: 0,
+    totalSize: 0,
+    files: []
+  };
+}
+
+// ../../workers/file-upload/src/usecase/DeleteFileUseCase.ts
+var DeleteFileUseCase = class {
+  constructor(r2Repository) {
+    this.r2Repository = r2Repository;
+  }
+  async execute(params) {
+    logger.info("DeleteFileUseCase.execute", params);
+    if (params.year) {
+      const deleted2 = await this.deleteFromYear(params.uuid, params.year);
+      if (deleted2) {
+        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");
+  }
+  async deleteFromYear(uuid, year) {
+    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;
+    }
+    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;
+  }
+  async deleteOldFormat(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;
+    }
+    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;
+  }
+  async removeFromYearFiles(uuid, year) {
+    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);
+  }
+};
+
+// ../../workers/file-upload/src/usecase/GetFileUseCase.ts
+var GetFileUseCase = class {
+  constructor(r2Repository) {
+    this.r2Repository = r2Repository;
+  }
+  async execute(params) {
+    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");
+  }
+};
+
+// ../../workers/file-upload/src/usecase/ListFilesUseCase.ts
+var ListFilesUseCase = class {
+  constructor(r2Repository) {
+    this.r2Repository = r2Repository;
+  }
+  async execute(params) {
+    const year = params.year ?? this.r2Repository.getCurrentYear();
+    logger.debug("ListFilesUseCase.execute", { year });
+    const yearFiles = await this.r2Repository.readYearFiles(year);
+    const availableYears = await this.r2Repository.getAvailableYears();
+    return {
+      year,
+      availableYears,
+      files: yearFiles.files,
+      totalSize: yearFiles.totalSize,
+      totalCount: yearFiles.totalCount,
+      baseUrl: this.r2Repository.getBaseUrl()
+    };
+  }
+  async getAvailableYears() {
+    const years = await this.r2Repository.getAvailableYears();
+    const currentYear = this.r2Repository.getCurrentYear();
+    return { years, currentYear };
+  }
+};
+
+// ../../workers/file-upload/src/usecase/RebuildIndexUseCase.ts
+var RebuildIndexUseCase = class {
+  constructor(r2Repository) {
+    this.r2Repository = r2Repository;
+  }
+  async execute(params) {
+    const { year } = params;
+    logger.info("RebuildIndexUseCase.execute", { year });
+    const files = [];
+    const movedFiles = [];
+    const yearObjects = await this.r2Repository.list(`${year}/`);
+    const grouped = this.groupObjectsByUuid(yearObjects, year);
+    const allObjects = await this.r2Repository.listAll();
+    const oldFormatGrouped = this.findOldFormatFiles(allObjects, year);
+    for (const [uuid, objects] of oldFormatGrouped) {
+      for (const obj of objects) {
+        const oldKey = obj.key;
+        const correctNewKey = `${year}/${obj.key}`;
+        const content = await this.r2Repository.get(oldKey);
+        if (content) {
+          await this.r2Repository.upload({
+            key: correctNewKey,
+            content: content.body,
+            contentType: content.info.httpMetadata?.contentType || "application/octet-stream",
+            customMetadata: content.info.customMetadata
+          });
+          await this.r2Repository.delete(oldKey);
+          movedFiles.push(`${oldKey} -> ${correctNewKey}`);
+        }
+      }
+      const movedObjects = await this.r2Repository.list(`${year}/${uuid}`);
+      if (movedObjects.length > 0) {
+        grouped.set(uuid, movedObjects);
+      }
+    }
+    for (const [uuid, objects] of grouped) {
+      const entry = this.buildFileEntry(uuid, objects, year);
+      if (entry) {
+        files.push(entry);
+      }
+    }
+    const yearFiles = {
+      year,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      totalCount: files.length,
+      totalSize: files.reduce((sum, f) => sum + f.size, 0),
+      files
+    };
+    await this.r2Repository.writeYearFiles(year, yearFiles);
+    logger.info("RebuildIndexUseCase.execute completed", {
+      year,
+      totalCount: files.length,
+      movedFilesCount: movedFiles.length
+    });
+    return {
+      success: true,
+      year,
+      totalCount: files.length,
+      movedFiles: movedFiles.length,
+      movedFilesList: movedFiles
+    };
+  }
+  groupObjectsByUuid(objects, year) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const obj of objects) {
+      if (obj.key === `${year}/files.json`) continue;
+      const pathAfterYear = obj.key.slice(`${year}/`.length);
+      const uuid = pathAfterYear.includes("/") ? pathAfterYear.split("/")[0] : pathAfterYear.split(".")[0];
+      if (!grouped.has(uuid)) grouped.set(uuid, []);
+      grouped.get(uuid).push(obj);
+    }
+    return grouped;
+  }
+  findOldFormatFiles(objects, year) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const obj of objects) {
+      if (/^\d{4}\//.test(obj.key)) continue;
+      const uuid = obj.key.includes("/") ? obj.key.split("/")[0] : obj.key.split(".")[0];
+      const fileYear = obj.uploaded.getFullYear();
+      if (fileYear === year) {
+        if (!grouped.has(uuid)) grouped.set(uuid, []);
+        grouped.get(uuid).push(obj);
+      }
+    }
+    return grouped;
+  }
+  buildFileEntry(uuid, objects, year) {
+    const isImageSet = objects.some((o) => {
+      const pathAfterYear = o.key.slice(`${year}/`.length);
+      return pathAfterYear.includes("/");
+    });
+    if (isImageSet) {
+      const variants = {};
+      let totalSize = 0;
+      let uploadedAt = "";
+      let originalName = "";
+      let uploadedBy = "unknown";
+      for (const obj of objects) {
+        const pathAfterYear = obj.key.slice(`${year}/`.length);
+        const preset = pathAfterYear.split("/")[1]?.replace(".webp", "");
+        if (preset) variants[preset] = obj.key;
+        totalSize += obj.size;
+        uploadedAt = obj.uploaded.toISOString();
+        originalName = obj.customMetadata?.originalName || uuid;
+        uploadedBy = obj.customMetadata?.uploadedBy || "unknown";
+      }
+      return {
+        uuid,
+        originalName,
+        contentType: "image/webp",
+        size: totalSize,
+        uploadedBy,
+        uploadedAt,
+        url: variants.thumbnail || variants.small || variants.medium || variants.large || variants.original || "",
+        variants
+      };
+    } else {
+      const obj = objects[0];
+      return {
+        uuid,
+        originalName: obj.customMetadata?.originalName || obj.key,
+        contentType: obj.httpMetadata?.contentType || "application/octet-stream",
+        size: obj.size,
+        uploadedBy: obj.customMetadata?.uploadedBy || "unknown",
+        uploadedAt: obj.uploaded.toISOString(),
+        url: obj.key
+      };
+    }
+  }
+};
+
+// ../../workers/file-upload/src/usecase/UpdateFileMetadataUseCase.ts
+var UpdateFileMetadataUseCase = class {
+  constructor(r2Repository) {
+    this.r2Repository = r2Repository;
+  }
+  async execute(params) {
+    logger.info("UpdateFileMetadataUseCase.execute", params);
+    const yearFiles = await this.r2Repository.readYearFiles(params.year);
+    const fileIndex = yearFiles.files.findIndex((f) => f.uuid === params.uuid);
+    if (fileIndex === -1) {
+      logger.warn("UpdateFileMetadataUseCase.execute", "File not found", { uuid: params.uuid });
+      throw new Error("File not found");
+    }
+    if (params.alt !== void 0) {
+      yearFiles.files[fileIndex].alt = params.alt || void 0;
+    }
+    yearFiles.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.r2Repository.writeYearFiles(params.year, yearFiles);
+    logger.info("UpdateFileMetadataUseCase.execute completed", { uuid: params.uuid });
+    return yearFiles.files[fileIndex];
+  }
+};
+
+// ../../workers/file-upload/src/usecase/UploadFileUseCase.ts
+var UploadFileUseCase = class {
+  constructor(r2Repository) {
+    this.r2Repository = r2Repository;
+  }
+  async execute(params) {
+    logger.info("UploadFileUseCase.execute", {
+      fileName: params.file.name,
+      uploadedBy: params.uploadedBy
+    });
+    const uuid = crypto.randomUUID();
+    const year = this.r2Repository.getCurrentYear();
+    const extension = params.file.name.split(".").pop() || "";
+    const key = extension ? `${year}/${uuid}.${extension}` : `${year}/${uuid}`;
+    const uploadedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.r2Repository.upload({
+      key,
+      content: params.file.stream(),
+      contentType: params.file.type,
+      customMetadata: {
+        originalName: params.file.name,
+        uploadedBy: params.uploadedBy
+      }
+    });
+    const yearFiles = await this.r2Repository.readYearFiles(year);
+    const newEntry = createFileEntry({
+      uuid,
+      originalName: params.file.name,
+      contentType: params.file.type,
+      size: params.file.size,
+      uploadedBy: params.uploadedBy,
+      uploadedAt,
+      publicUrl: key
+    });
+    yearFiles.files.push(newEntry);
+    const updatedYearFiles = recalculateYearFilesStats(yearFiles);
+    await this.r2Repository.writeYearFiles(year, updatedYearFiles);
+    logger.info("UploadFileUseCase.execute completed", { uuid });
+    return newEntry;
+  }
+};
+
+// ../../workers/file-upload/src/usecase/UploadImageSetUseCase.ts
+var UploadImageSetUseCase = class {
+  constructor(r2Repository) {
+    this.r2Repository = r2Repository;
+  }
+  async execute(params) {
+    logger.info("UploadImageSetUseCase.execute", {
+      originalName: params.originalName,
+      uploadedBy: params.uploadedBy,
+      presetCount: params.files.size
+    });
+    const uuid = crypto.randomUUID();
+    const year = this.r2Repository.getCurrentYear();
+    const uploadedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const variants = {};
+    let totalSize = 0;
+    for (const name of PRESET_NAMES) {
+      const file = params.files.get(name);
+      if (file) {
+        const key = `${year}/${uuid}/${name}.webp`;
+        await this.r2Repository.upload({
+          key,
+          content: file.stream(),
+          contentType: "image/webp",
+          customMetadata: {
+            originalName: params.originalName,
+            uploadedBy: params.uploadedBy
+          }
+        });
+        variants[name] = key;
+        totalSize += file.size;
+      }
+    }
+    const thumbnailUrl = selectThumbnailUrl(variants);
+    const yearFiles = await this.r2Repository.readYearFiles(year);
+    const newEntry = createFileEntry({
+      uuid,
+      originalName: params.originalName,
+      contentType: "image/webp",
+      size: totalSize,
+      uploadedBy: params.uploadedBy,
+      uploadedAt,
+      publicUrl: thumbnailUrl,
+      width: params.width,
+      height: params.height,
+      variants
+    });
+    yearFiles.files.push(newEntry);
+    const updatedYearFiles = recalculateYearFilesStats(yearFiles);
+    await this.r2Repository.writeYearFiles(year, updatedYearFiles);
+    logger.info("UploadImageSetUseCase.execute completed", { uuid, variantCount: Object.keys(variants).length });
+    return newEntry;
+  }
+  /**
+   * プリウォーム用の URL 一覧を取得
+   */
+  getPrewarmUrls(variants) {
+    return Object.values(variants);
+  }
+};
+
+// ../../workers/file-upload/src/controller/FileController.ts
+var FileController = class {
+  presenter;
+  uploadFileUseCase;
+  uploadImageSetUseCase;
+  deleteFileUseCase;
+  listFilesUseCase;
+  getFileUseCase;
+  updateFileMetadataUseCase;
+  rebuildIndexUseCase;
+  constructor(r2Repository, 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() {
+    return this.presenter.cors();
+  }
+  /**
+   * POST /upload - 単一ファイルのアップロード
+   */
+  async handleUpload(request) {
+    const formData = await request.formData();
+    const file = formData.get("file");
+    const uploadedBy = formData.get("uploadedBy");
+    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.message);
+    }
+  }
+  /**
+   * POST /upload-set - 画像セットのアップロード
+   */
+  async handleUploadSet(request, ctx) {
+    const formData = await request.formData();
+    const uploadedBy = formData.get("uploadedBy");
+    const originalName = formData.get("originalName");
+    if (!uploadedBy) {
+      return this.presenter.badRequest("uploadedBy is required");
+    }
+    if (!originalName) {
+      return this.presenter.badRequest("originalName is required");
+    }
+    const files = /* @__PURE__ */ new Map();
+    const presetNames = ["original", "retina", "large", "medium", "small", "thumbnail"];
+    for (const name of presetNames) {
+      const file = formData.get(name);
+      if (file) {
+        files.set(name, file);
+      }
+    }
+    if (files.size === 0) {
+      return this.presenter.badRequest("No image files provided");
+    }
+    const widthStr = formData.get("width");
+    const heightStr = formData.get("height");
+    const width = widthStr ? parseInt(widthStr) : void 0;
+    const height = heightStr ? parseInt(heightStr) : void 0;
+    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.message);
+    }
+  }
+  /**
+   * GET /years - 利用可能な年一覧
+   */
+  async handleGetYears() {
+    try {
+      const result = await this.listFilesUseCase.getAvailableYears();
+      return this.presenter.ok(result);
+    } catch (error) {
+      logger.error("FileController.handleGetYears", { error });
+      return this.presenter.serverError(error.message);
+    }
+  }
+  /**
+   * GET /list - ファイル一覧
+   */
+  async handleListFiles(url) {
+    const yearParam = url.searchParams.get("year");
+    const year = yearParam ? parseInt(yearParam) : void 0;
+    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.message);
+    }
+  }
+  /**
+   * GET /files/:uuid - ファイル情報
+   */
+  async handleGetFile(uuid) {
+    try {
+      const result = await this.getFileUseCase.execute({ uuid });
+      return this.presenter.ok(result);
+    } catch (error) {
+      if (error.message === "File not found") {
+        return this.presenter.notFound("File not found");
+      }
+      logger.error("FileController.handleGetFile", { error });
+      return this.presenter.serverError(error.message);
+    }
+  }
+  /**
+   * PATCH /files/:uuid - メタデータ更新
+   */
+  async handleUpdateFileMetadata(uuid, request) {
+    const body = await request.json();
+    const { year, alt } = body;
+    if (year === void 0) {
+      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.message === "File not found") {
+        return this.presenter.notFound("File not found");
+      }
+      logger.error("FileController.handleUpdateFileMetadata", { error });
+      return this.presenter.serverError(error.message);
+    }
+  }
+  /**
+   * DELETE /files/:uuid - ファイル削除
+   */
+  async handleDeleteFile(uuid, url) {
+    const yearParam = url.searchParams.get("year");
+    const year = yearParam ? parseInt(yearParam) : void 0;
+    try {
+      const result = await this.deleteFileUseCase.execute({ uuid, year });
+      return this.presenter.ok(result);
+    } catch (error) {
+      if (error.message === "File not found") {
+        return this.presenter.notFound("File not found");
+      }
+      logger.error("FileController.handleDeleteFile", { error });
+      return this.presenter.serverError(error.message);
+    }
+  }
+  /**
+   * POST /rebuild/:year - インデックス再構築
+   */
+  async handleRebuildIndex(year) {
+    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.message);
+    }
+  }
+  /**
+   * Not Found
+   */
+  handleNotFound() {
+    return this.presenter.notFound();
+  }
+  /**
+   * プリウォーム: CDN キャッシュを温める
+   */
+  async prewarmUrls(urls) {
+    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}`
+    );
+  }
+};
+
+// ../../workers/file-upload/src/domain/AuthEntity.ts
+var AuthError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "AuthError";
+  }
+};
+
+// ../../workers/file-upload/src/repository/GitHubAuthRepositoryImpl.ts
+var tokenCache = /* @__PURE__ */ new Map();
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var GitHubAuthRepositoryImpl = class {
+  async validateToken(token) {
+    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();
+      const user = { login: data.login };
+      tokenCache.set(token, {
+        user,
+        expiresAt: Date.now() + CACHE_TTL_MS
+      });
+      return user;
+    } catch (error) {
+      logger.error("GitHubAuthRepositoryImpl.validateToken", { error });
+      return null;
+    }
+  }
+};
+
+// ../../workers/file-upload/src/repository/R2RepositoryImpl.ts
+var R2RepositoryImpl = class {
+  constructor(bucket, publicUrl) {
+    this.bucket = bucket;
+    this.publicUrl = publicUrl;
+  }
+  async upload(params) {
+    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) {
+    logger.debug("R2RepositoryImpl.delete", { key });
+    await this.bucket.delete(key);
+  }
+  async deleteMany(keys) {
+    logger.debug("R2RepositoryImpl.deleteMany", { count: keys.length });
+    await Promise.all(keys.map((key) => this.bucket.delete(key)));
+  }
+  async head(key) {
+    const obj = await this.bucket.head(key);
+    if (!obj) return null;
+    return this.toObjectInfo(obj);
+  }
+  async get(key) {
+    const obj = await this.bucket.get(key);
+    if (!obj) return null;
+    return {
+      body: obj.body,
+      info: this.toObjectInfo(obj)
+    };
+  }
+  async list(prefix) {
+    const result = [];
+    let cursor;
+    do {
+      const listed = await this.bucket.list({
+        prefix,
+        cursor,
+        include: ["httpMetadata", "customMetadata"]
+      });
+      for (const obj of listed.objects) {
+        result.push(this.toObjectInfo(obj));
+      }
+      cursor = listed.truncated ? listed.cursor : void 0;
+    } while (cursor);
+    return result;
+  }
+  async listAll() {
+    const result = [];
+    let cursor;
+    do {
+      const listed = await this.bucket.list({
+        cursor,
+        include: ["httpMetadata", "customMetadata"]
+      });
+      for (const obj of listed.objects) {
+        result.push(this.toObjectInfo(obj));
+      }
+      cursor = listed.truncated ? listed.cursor : void 0;
+    } while (cursor);
+    return result;
+  }
+  async readYearFiles(year) {
+    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, data) {
+    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() {
+    const years = /* @__PURE__ */ new Set();
+    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() {
+    return (/* @__PURE__ */ new Date()).getFullYear();
+  }
+  getBaseUrl() {
+    return this.publicUrl;
+  }
+  toObjectInfo(obj) {
+    return {
+      key: obj.key,
+      size: obj.size,
+      uploaded: obj.uploaded,
+      httpMetadata: obj.httpMetadata ? {
+        contentType: obj.httpMetadata.contentType
+      } : void 0,
+      customMetadata: obj.customMetadata
+    };
+  }
+};
+
+// ../../workers/file-upload/src/usecase/ValidateAuthUseCase.ts
+var ValidateAuthUseCase = class {
+  constructor(authRepository) {
+    this.authRepository = authRepository;
+  }
+  async execute(authHeader) {
+    if (!authHeader || !authHeader.startsWith("Bearer ")) {
+      throw new AuthError("Missing or invalid Authorization header", 401);
+    }
+    const token = authHeader.slice(7);
+    const user = await this.authRepository.validateToken(token);
+    if (!user) {
+      throw new AuthError("Invalid token", 401);
+    }
+    return user;
+  }
+};
+
+// functions/api/storage/_middleware.ts
+var onRequest = async (context) => {
+  const requestId = crypto.randomUUID().slice(0, 8);
+  logger.setRequestId(requestId);
+  try {
+    const origin = context.request.headers.get("Origin") ?? "";
+    const allowedOrigins = context.env.ALLOWED_ORIGINS?.split(",").map((s) => s.trim()) ?? [];
+    const isSameOrigin = origin === new URL(context.request.url).origin;
+    const matchedOrigin = isSameOrigin || 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"
+    };
+    if (context.request.method === "OPTIONS") {
+      return new Response(null, { headers: corsHeaders });
+    }
+    const authRepository = new GitHubAuthRepositoryImpl();
+    const validateAuth = new ValidateAuthUseCase(authRepository);
+    const presenter = new HttpPresenterImpl(corsHeaders);
+    try {
+      await validateAuth.execute(context.request.headers.get("Authorization"));
+    } catch (error) {
+      if (error instanceof AuthError) {
+        return presenter.unauthorized(error.message);
+      }
+      throw error;
+    }
+    const r2Repository = new R2RepositoryImpl(context.env.R2, context.env.R2_PUBLIC_URL);
+    context.data.controller = new FileController(r2Repository, corsHeaders);
+    return await context.next();
+  } catch (error) {
+    logger.error("StorageMiddleware", "Unhandled error", { error });
+    return new Response(JSON.stringify({ error: error.message }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" }
+    });
+  } finally {
+    logger.clearRequestId();
+  }
+};
+export {
+  onRequest
+};