@filebox/s3-server 1.0.0 → 1.0.1

package/handlers/deleteObject.js

@@ -1,77 +0,0 @@
-const Responses = require("../responses");
-
-/**
- * 处理S3 DeleteObject请求
- * 从存储桶中删除对象
- */
-class DeleteObject {
-  constructor(server) {
-    this.server = server;
-    this.handle = this.handle.bind(this);
-  }
-
-  /**
-   * 处理DeleteObject请求
-   * @param {object} req - Express请求对象
-   * @param {object} res - Express响应对象
-   */
-  async handle(req, res) {
-    try {
-      // 获取存储桶和键
-      const { bucket, key } = this.extractBucketAndKey(req);
-
-      if (!bucket) {
-        await Responses.error(res, 404, "NoSuchBucket", "存储桶不存在");
-        return;
-      }
-
-      if (!key) {
-        await Responses.error(res, 400, "InvalidRequest", "无效的对象键");
-        return;
-      }
-
-      // 构建对象路径
-      const objectPath = `/${bucket}/${key}`;
-
-      // 检查对象是否存在
-      const stats = await this.server.driver.stat(objectPath);
-
-      if (!stats) {
-        // S3兼容性：即使对象不存在也返回成功
-        await Responses.noContent(res);
-        return;
-      }
-
-      if (stats.isDirectory) {
-        await Responses.error(res, 400, "InvalidRequest", "请求的键是一个目录");
-        return;
-      }
-
-      // 删除对象
-      await this.server.driver.unlink(objectPath);
-
-      // 返回成功响应
-      await Responses.noContent(res);
-    } catch (error) {
-      console.error("Error in DeleteObject:", error);
-      await Responses.error(res, 500, "InternalError", "服务器内部错误");
-    }
-  }
-
-  /**
-   * 从请求参数中提取存储桶和键
-   * @param {object} req - Express请求对象
-   * @returns {object} 包含存储桶和键的对象
-   */
-  extractBucketAndKey(req) {
-    const url = new URL(req.url, `http://${req.headers.host}`);
-    const pathParts = url.pathname.split("/").filter(Boolean);
-
-    return {
-      bucket: pathParts[0],
-      key: pathParts.slice(1).join("/"),
-    };
-  }
-}
-
-module.exports = DeleteObject;

package/handlers/deleteObjects.js

@@ -1,148 +0,0 @@
-const Responses = require("../responses");
-const { parseStringPromise } = require("xml2js");
-
-/**
- * 处理S3 DeleteObjects请求
- * 批量删除多个对象
- */
-class DeleteObjects {
-  constructor(server) {
-    this.server = server;
-    this.handle = this.handle.bind(this);
-  }
-
-  /**
-   * 处理DeleteObjects请求
-   * @param {object} req - Express请求对象
-   * @param {object} res - Express响应对象
-   */
-  async handle(req, res) {
-    try {
-      // 获取存储桶名称
-      const { bucket } = this.extractBucketAndKey(req);
-
-      if (!bucket) {
-        await Responses.error(res, 404, "NoSuchBucket", "存储桶不存在");
-        return;
-      }
-
-      // 检查存储桶是否存在
-      const bucketExists = await this.server.driver.bucketExists(bucket);
-
-      if (!bucketExists) {
-        await Responses.error(res, 404, "NoSuchBucket", "存储桶不存在");
-        return;
-      }
-
-      // 解析请求体中的XML
-      const body = await this.getRequestBody(req);
-      let deleteData;
-
-      try {
-        const parsedXml = await parseStringPromise(body);
-        deleteData = parsedXml.Delete;
-      } catch (error) {
-        await Responses.error(res, 400, "MalformedXML", "XML格式错误");
-        return;
-      }
-
-      if (
-        !deleteData ||
-        !deleteData.Object ||
-        !Array.isArray(deleteData.Object)
-      ) {
-        await Responses.error(res, 400, "MalformedXML", "无效的删除请求");
-        return;
-      }
-
-      // 提取要删除的对象键
-      const objectsToDelete = deleteData.Object.map((obj) => ({
-        Key: obj.Key[0],
-      }));
-
-      // 批量删除对象
-      const deleted = [];
-      const errors = [];
-
-      for (const obj of objectsToDelete) {
-        try {
-          const objectPath = `/${bucket}/${obj.Key}`;
-
-          // 检查对象是否存在
-          const stats = await this.server.driver.stat(objectPath);
-
-          if (!stats) {
-            // 对象不存在，但按照S3规范，仍然视为成功删除
-            deleted.push({ Key: obj.Key });
-            continue;
-          }
-
-          if (stats.isDirectory) {
-            errors.push({
-              Key: obj.Key,
-              Code: "InvalidRequest",
-              Message: "请求的键是一个目录",
-            });
-            continue;
-          }
-
-          // 删除对象
-          await this.server.driver.unlink(objectPath);
-          deleted.push({ Key: obj.Key });
-        } catch (error) {
-          errors.push({
-            Key: obj.Key,
-            Code: "InternalError",
-            Message: "删除对象时发生错误",
-          });
-        }
-      }
-
-      // 返回删除结果
-      await Responses.deleteObjects(res, deleted, errors);
-    } catch (error) {
-      console.error("Error in DeleteObjects:", error);
-      await Responses.error(res, 500, "InternalError", "服务器内部错误");
-    }
-  }
-
-  /**
-   * 从请求参数中提取存储桶和键
-   * @param {object} req - Express请求对象
-   * @returns {object} 包含存储桶和键的对象
-   */
-  extractBucketAndKey(req) {
-    const url = new URL(req.url, `http://${req.headers.host}`);
-    const pathParts = url.pathname.split("/").filter(Boolean);
-
-    return {
-      bucket: pathParts[0],
-      key: pathParts.slice(1).join("/"),
-    };
-  }
-
-  /**
-   * 获取请求体内容
-   * @param {object} req - Express请求对象
-   * @returns {Promise<string>} 请求体内容
-   */
-  getRequestBody(req) {
-    return new Promise((resolve, reject) => {
-      let body = "";
-
-      req.on("data", (chunk) => {
-        body += chunk.toString();
-      });
-
-      req.on("end", () => {
-        resolve(body);
-      });
-
-      req.on("error", (error) => {
-        reject(error);
-      });
-    });
-  }
-}
-
-module.exports = DeleteObjects;

package/handlers/getObject.js

@@ -1,195 +0,0 @@
-const Responses = require("../responses");
-const path = require("path");
-const crypto = require("crypto");
-
-/**
- * 处理S3 GetObject请求
- * 获取对象内容
- */
-class GetObject {
-  constructor(server) {
-    this.server = server;
-    this.handle = this.handle.bind(this);
-  }
-
-  /**
-   * 处理GetObject请求
-   * @param {object} req - Express请求对象
-   * @param {object} res - Express响应对象
-   */
-  async handle(req, res) {
-    try {
-      // 获取存储桶和键
-      const { bucket, key } = this.extractBucketAndKey(req);
-
-      if (!bucket) {
-        await Responses.error(res, 404, "NoSuchBucket", "存储桶不存在");
-        return;
-      }
-
-      if (!key) {
-        await Responses.error(res, 400, "InvalidRequest", "无效的对象键");
-        return;
-      }
-
-      // 构建对象路径
-      const objectPath = `/${bucket}/${key}`;
-
-      // 获取对象信息
-      const stats = await this.server.driver.stat(objectPath);
-
-      if (!stats) {
-        await Responses.error(res, 404, "NoSuchKey", "对象不存在");
-        return;
-      }
-
-      if (stats.isDirectory) {
-        await Responses.error(res, 400, "InvalidRequest", "请求的键是一个目录");
-        return;
-      }
-
-      // 设置响应头
-      res.set("Content-Type", this.getContentType(key));
-      res.set("Content-Length", stats.size.toString());
-      res.set("Last-Modified", new Date(stats.mtime).toUTCString());
-      res.set("ETag", `"${stats.uuid || crypto.randomUUID()}"`);
-      res.set("Accept-Ranges", "bytes");
-      res.set("Date", new Date().toUTCString());
-
-      // 处理范围请求
-      if (req.headers.range) {
-        const range = this.parseRange(req.headers.range, stats.size);
-
-        if (range) {
-          res.set(
-            "Content-Range",
-            `bytes ${range.start}-${range.end}/${stats.size}`,
-          );
-          res.set("Content-Length", (range.end - range.start + 1).toString());
-          res.status(206); // Partial Content
-        } else {
-          res.set("Content-Range", `bytes */${stats.size}`);
-          res.status(416); // Range Not Satisfiable
-          res.end();
-          return;
-        }
-      } else {
-        res.status(200);
-      }
-
-      // 流式传输对象内容
-      const stream = await this.server.driver.createReadStream(objectPath, {
-        start: range?.start,
-        end: range?.end,
-      });
-
-      stream.pipe(res);
-
-      // 处理错误
-      stream.on("error", async (error) => {
-        console.error("Error streaming object:", error);
-        if (!res.headersSent) {
-          await Responses.error(
-            res,
-            500,
-            "InternalError",
-            "读取对象时发生错误",
-          );
-        } else {
-          res.end();
-        }
-      });
-    } catch (error) {
-      console.error("Error in GetObject:", error);
-      if (!res.headersSent) {
-        await Responses.error(res, 500, "InternalError", "服务器内部错误");
-      }
-    }
-  }
-
-  /**
-   * 从请求参数中提取存储桶和键
-   * @param {object} req - Express请求对象
-   * @returns {object} 包含存储桶和键的对象
-   */
-  extractBucketAndKey(req) {
-    const url = new URL(req.url, `http://${req.headers.host}`);
-    const pathParts = url.pathname.split("/").filter(Boolean);
-
-    return {
-      bucket: pathParts[0],
-      key: pathParts.slice(1).join("/"),
-    };
-  }
-
-  /**
-   * 根据文件扩展名获取内容类型
-   * @param {string} filename - 文件名
-   * @returns {string} 内容类型
-   */
-  getContentType(filename) {
-    const ext = path.extname(filename).toLowerCase();
-
-    const mimeTypes = {
-      ".html": "text/html",
-      ".htm": "text/html",
-      ".css": "text/css",
-      ".js": "application/javascript",
-      ".json": "application/json",
-      ".png": "image/png",
-      ".jpg": "image/jpeg",
-      ".jpeg": "image/jpeg",
-      ".gif": "image/gif",
-      ".webp": "image/webp",
-      ".svg": "image/svg+xml",
-      ".pdf": "application/pdf",
-      ".txt": "text/plain",
-      ".xml": "application/xml",
-      ".zip": "application/zip",
-      ".mp3": "audio/mpeg",
-      ".mp4": "video/mp4",
-      ".webm": "video/webm",
-      ".doc": "application/msword",
-      ".docx":
-        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-      ".xls": "application/vnd.ms-excel",
-      ".xlsx":
-        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-      ".ppt": "application/vnd.ms-powerpoint",
-      ".pptx":
-        "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-    };
-
-    return mimeTypes[ext] || "application/octet-stream";
-  }
-
-  /**
-   * 解析Range头
-   * @param {string} rangeHeader - Range头值
-   * @param {number} size - 文件大小
-   * @returns {object|null} 范围对象或null
-   */
-  parseRange(rangeHeader, size) {
-    const matches = rangeHeader.match(/bytes=(\d+)-(\d*)/);
-
-    if (!matches) return null;
-
-    const start = parseInt(matches[1], 10);
-    const end = matches[2] ? parseInt(matches[2], 10) : size - 1;
-
-    // 验证范围
-    if (
-      isNaN(start) ||
-      isNaN(end) ||
-      start > end ||
-      start >= size ||
-      end >= size
-    ) {
-      return null;
-    }
-
-    return { start, end };
-  }
-}
-
-module.exports = GetObject;

package/handlers/headBucket.js

@@ -1,72 +0,0 @@
-const Responses = require("../responses");
-
-/**
- * 处理S3 HeadBucket请求
- * 检查存储桶是否存在且用户是否有权限访问
- */
-class HeadBucket {
-  constructor(server) {
-    this.server = server;
-    this.handle = this.handle.bind(this);
-  }
-
-  /**
-   * 处理HeadBucket请求
-   * @param {object} req - Express请求对象
-   * @param {object} res - Express响应对象
-   */
-  async handle(req, res) {
-    try {
-      // 获取存储桶名称
-      const { bucket } = this.extractBucketAndKey(req);
-
-      if (!bucket) {
-        res.status(404).end();
-        return;
-      }
-
-      // 检查存储桶是否存在
-      const bucketExists = await this.server.driver.bucketExists(bucket);
-
-      if (!bucketExists) {
-        res.status(404).end();
-        return;
-      }
-
-      // 检查是否有权限访问存储桶
-      const hasAccess = await this.server.driver.hasBucketAccess(bucket);
-
-      if (!hasAccess) {
-        res.status(403).end();
-        return;
-      }
-
-      // 设置响应头
-      res.set("Date", new Date().toUTCString());
-      res.set("x-amz-bucket-region", this.server.config.region || "default");
-
-      // 返回成功响应
-      res.status(200).end();
-    } catch (error) {
-      console.error("Error in HeadBucket:", error);
-      res.status(500).end();
-    }
-  }
-
-  /**
-   * 从请求参数中提取存储桶和键
-   * @param {object} req - Express请求对象
-   * @returns {object} 包含存储桶和键的对象
-   */
-  extractBucketAndKey(req) {
-    const url = new URL(req.url, `http://${req.headers.host}`);
-    const pathParts = url.pathname.split("/").filter(Boolean);
-
-    return {
-      bucket: pathParts[0],
-      key: pathParts.slice(1).join("/"),
-    };
-  }
-}
-
-module.exports = HeadBucket;

package/handlers/headObject.js

@@ -1,134 +0,0 @@
-const Responses = require("../responses");
-const path = require("path");
-const crypto = require("crypto");
-
-/**
- * 处理S3 HeadObject请求
- * 获取对象元数据，不返回对象内容
- */
-class HeadObject {
-  constructor(server) {
-    this.server = server;
-    this.handle = this.handle.bind(this);
-  }
-
-  /**
-   * 处理HeadObject请求
-   * @param {object} req - Express请求对象
-   * @param {object} res - Express响应对象
-   */
-  async handle(req, res) {
-    try {
-      // 获取存储桶和键
-      const { bucket, key } = this.extractBucketAndKey(req);
-
-      if (!bucket) {
-        res.status(404).end();
-        return;
-      }
-
-      if (!key) {
-        res.status(400).end();
-        return;
-      }
-
-      // 构建对象路径
-      const objectPath = `/${bucket}/${key}`;
-
-      // 获取对象信息
-      const stats = await this.server.driver.stat(objectPath);
-
-      if (!stats) {
-        res.status(404).end();
-        return;
-      }
-
-      if (stats.isDirectory) {
-        res.status(400).end();
-        return;
-      }
-
-      // 设置响应头
-      res.set("Content-Type", this.getContentType(key));
-      res.set("Content-Length", stats.size.toString());
-      res.set("Last-Modified", new Date(stats.mtime).toUTCString());
-      res.set("ETag", `"${stats.uuid || crypto.randomUUID()}"`);
-      res.set("Accept-Ranges", "bytes");
-      res.set("Date", new Date().toUTCString());
-
-      // 添加S3特定的元数据头
-      const metadata = await this.server.driver.getObjectMetadata(objectPath);
-      if (metadata) {
-        Object.entries(metadata).forEach(([key, value]) => {
-          if (key.startsWith("x-amz-meta-")) {
-            res.set(key, value);
-          }
-        });
-      }
-
-      // 返回空响应体
-      res.status(200).end();
-    } catch (error) {
-      console.error("Error in HeadObject:", error);
-      res.status(500).end();
-    }
-  }
-
-  /**
-   * 从请求参数中提取存储桶和键
-   * @param {object} req - Express请求对象
-   * @returns {object} 包含存储桶和键的对象
-   */
-  extractBucketAndKey(req) {
-    const url = new URL(req.url, `http://${req.headers.host}`);
-    const pathParts = url.pathname.split("/").filter(Boolean);
-
-    return {
-      bucket: pathParts[0],
-      key: pathParts.slice(1).join("/"),
-    };
-  }
-
-  /**
-   * 根据文件扩展名获取内容类型
-   * @param {string} filename - 文件名
-   * @returns {string} 内容类型
-   */
-  getContentType(filename) {
-    const ext = path.extname(filename).toLowerCase();
-
-    const mimeTypes = {
-      ".html": "text/html",
-      ".htm": "text/html",
-      ".css": "text/css",
-      ".js": "application/javascript",
-      ".json": "application/json",
-      ".png": "image/png",
-      ".jpg": "image/jpeg",
-      ".jpeg": "image/jpeg",
-      ".gif": "image/gif",
-      ".webp": "image/webp",
-      ".svg": "image/svg+xml",
-      ".pdf": "application/pdf",
-      ".txt": "text/plain",
-      ".xml": "application/xml",
-      ".zip": "application/zip",
-      ".mp3": "audio/mpeg",
-      ".mp4": "video/mp4",
-      ".webm": "video/webm",
-      ".doc": "application/msword",
-      ".docx":
-        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-      ".xls": "application/vnd.ms-excel",
-      ".xlsx":
-        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-      ".ppt": "application/vnd.ms-powerpoint",
-      ".pptx":
-        "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-    };
-
-    return mimeTypes[ext] || "application/octet-stream";
-  }
-}
-
-module.exports = HeadObject;

package/handlers/listBuckets.js

@@ -1,38 +0,0 @@
-const Responses = require("../responses");
-
-/**
- * 处理S3 ListBuckets请求
- * 列出所有可用的存储桶
- */
-class ListBuckets {
-  constructor(server) {
-    this.server = server;
-    this.handle = this.handle.bind(this);
-  }
-
-  /**
-   * 处理ListBuckets请求
-   * @param {object} req - Express请求对象
-   * @param {object} res - Express响应对象
-   */
-  async handle(req, res) {
-    try {
-      // 从驱动获取存储桶列表
-      const buckets = await this.server.driver.listBuckets();
-
-      // 获取所有者信息
-      const owner = {
-        id: this.server.config.accessKeyId || "anonymous",
-        displayName: this.server.config.displayName || "S3 User",
-      };
-
-      // 返回存储桶列表
-      await Responses.listBuckets(res, buckets, owner);
-    } catch (error) {
-      console.error("Error in ListBuckets:", error);
-      await Responses.error(res, 500, "InternalError", "服务器内部错误");
-    }
-  }
-}
-
-module.exports = ListBuckets;