@filebox/s3-server 1.0.0 → 1.0.1

package/package.json

@@ -1,31 +1,37 @@
 {
   "name": "@filebox/s3-server",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "license": "MIT",
   "description": "S3-compatible server adapter for FileBox drivers",
-  "main": "./index.js",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "default": "./index.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
     }
   },
   "files": [
-    "index.js",
-    "context.js",
-    "driver.js",
-    "responses.js",
-    "handlers",
-    "LICENSE",
-    "README.md"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "build": "node build.mjs",
+    "prepack": "node build.mjs"
+  },
   "dependencies": {
-    "express": "^4.18.2",
-    "xml2js": "^0.6.2",
-    "uuid": "^9.0.1",
-    "body-parser": "^1.20.2"
-  }
-} 
+    "express": "^4.18.2",
+    "xml2js": "^0.6.2",
+    "uuid": "^9.0.1",
+    "body-parser": "^1.20.2"
+  },
+  "devDependencies": {
+    "esbuild": "^0.24.0"
+  }
+}

package/context.js

@@ -1,62 +0,0 @@
-/**
- * 创建S3请求上下文
- * @param {object} req - Express请求对象
- * @param {string} region - S3区域
- * @returns {object} 上下文对象
- */
-const createContext = (req) => {
-  const authorization = req.headers?.authorization?.split(" ")[1];
-  const url = new URL(req.url, `http://${req.headers.host}`);
-  const path = url.pathname;
-
-  // 解析查询参数
-  const query = {};
-  url.searchParams.forEach((value, key) => {
-    query[key] = value;
-  });
-
-  const ctx = {
-    req: req,
-    method: (req.method || "").toLowerCase(),
-    path: path,
-    query: query,
-    auth: { accessKeyId: undefined, secretAccessKey: undefined },
-
-    // 获取请求头
-    get(field) {
-      const req = this.req;
-      switch ((field = field.toLowerCase())) {
-        case "referer":
-        case "referrer":
-          return req.headers.referrer || req.headers.referer || "";
-        default:
-          return req.headers[field] || "";
-      }
-    },
-
-    // 解析S3请求参数
-    getBucketAndKey() {
-      // 从路径中提取bucket和key
-      const parts = this.path.split("/").filter(Boolean);
-      const bucket = parts[0];
-      const key = parts.slice(1).join("/");
-
-      return { bucket, key };
-    },
-  };
-
-  // 解析认证信息
-  if (authorization) {
-    try {
-      const decoded = Buffer.from(authorization, "base64").toString("utf8");
-      const [accessKeyId, secretAccessKey] = decoded.split(":");
-      ctx.auth = { accessKeyId, secretAccessKey };
-    } catch (error) {
-      // 认证解析失败
-    }
-  }
-
-  return ctx;
-};
-
-module.exports = createContext;

package/driver.js

@@ -1,337 +0,0 @@
-const path = require("path");
-const fs = require("fs").promises;
-const { createReadStream, createWriteStream } = require("fs");
-const { Readable } = require("stream");
-const crypto = require("crypto");
-
-/**
- * S3驱动程序接口
- * 定义了S3服务器所需的所有存储操作
- */
-class S3Driver {
-  /**
-   * 创建S3驱动程序实例
-   * @param {Object} config - 驱动配置
-   */
-  constructor(config = {}) {
-    this.config = {
-      rootDir: config.rootDir || "./s3-data",
-      ...config,
-    };
-  }
-
-  /**
-   * 确保目录存在
-   * @param {string} dirPath - 目录路径
-   * @returns {Promise<void>}
-   */
-  async ensureDir(dirPath) {
-    try {
-      await fs.mkdir(dirPath, { recursive: true });
-    } catch (error) {
-      if (error.code !== "EEXIST") {
-        throw error;
-      }
-    }
-  }
-
-  /**
-   * 获取存储桶路径
-   * @param {string} bucket - 存储桶名称
-   * @returns {string} 存储桶完整路径
-   */
-  getBucketPath(bucket) {
-    return path.join(this.config.rootDir, bucket);
-  }
-
-  /**
-   * 获取对象路径
-   * @param {string} objectPath - 对象路径（格式：/bucket/key）
-   * @returns {string} 对象完整路径
-   */
-  getObjectPath(objectPath) {
-    // 移除开头的斜杠
-    const normalizedPath = objectPath.startsWith("/")
-      ? objectPath.slice(1)
-      : objectPath;
-    return path.join(this.config.rootDir, normalizedPath);
-  }
-
-  /**
-   * 检查存储桶是否存在
-   * @param {string} bucket - 存储桶名称
-   * @returns {Promise<boolean>} 存储桶是否存在
-   */
-  async bucketExists(bucket) {
-    try {
-      const bucketPath = this.getBucketPath(bucket);
-      const stats = await fs.stat(bucketPath);
-      return stats.isDirectory();
-    } catch (error) {
-      return false;
-    }
-  }
-
-  /**
-   * 检查是否是存储桶所有者
-   * @param {string} bucket - 存储桶名称
-   * @returns {Promise<boolean>} 是否是存储桶所有者
-   */
-  async isBucketOwner(bucket) {
-    // 在此实现中，假设所有存在的存储桶都属于当前用户
-    return await this.bucketExists(bucket);
-  }
-
-  /**
-   * 检查是否有权限访问存储桶
-   * @param {string} bucket - 存储桶名称
-   * @returns {Promise<boolean>} 是否有权限访问
-   */
-  async hasBucketAccess(bucket) {
-    // 在此实现中，假设所有存在的存储桶都可以访问
-    return await this.bucketExists(bucket);
-  }
-
-  /**
-   * 检查存储桶是否为空
-   * @param {string} bucket - 存储桶名称
-   * @returns {Promise<boolean>} 存储桶是否为空
-   */
-  async isBucketEmpty(bucket) {
-    try {
-      const bucketPath = this.getBucketPath(bucket);
-      const files = await fs.readdir(bucketPath);
-      return files.length === 0;
-    } catch (error) {
-      // 如果存储桶不存在，视为空
-      return true;
-    }
-  }
-
-  /**
-   * 创建存储桶
-   * @param {string} bucket - 存储桶名称
-   * @returns {Promise<void>}
-   */
-  async createBucket(bucket) {
-    const bucketPath = this.getBucketPath(bucket);
-    await this.ensureDir(bucketPath);
-
-    // 创建元数据文件
-    const metadataPath = path.join(bucketPath, ".metadata.json");
-    const metadata = {
-      creationDate: Date.now(),
-      owner: this.config.owner || "default",
-    };
-
-    await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
-  }
-
-  /**
-   * 删除存储桶
-   * @param {string} bucket - 存储桶名称
-   * @returns {Promise<void>}
-   */
-  async deleteBucket(bucket) {
-    const bucketPath = this.getBucketPath(bucket);
-    await fs.rmdir(bucketPath, { recursive: true });
-  }
-
-  /**
-   * 列出所有存储桶
-   * @returns {Promise<Array>} 存储桶列表
-   */
-  async listBuckets() {
-    try {
-      // 确保根目录存在
-      await this.ensureDir(this.config.rootDir);
-
-      // 读取根目录下的所有目录
-      const entries = await fs.readdir(this.config.rootDir, {
-        withFileTypes: true,
-      });
-      const buckets = [];
-
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          try {
-            // 尝试读取存储桶元数据
-            const metadataPath = path.join(
-              this.config.rootDir,
-              entry.name,
-              ".metadata.json",
-            );
-            let metadata;
-
-            try {
-              const data = await fs.readFile(metadataPath, "utf8");
-              metadata = JSON.parse(data);
-            } catch (error) {
-              // 如果元数据文件不存在或无效，使用默认值
-              metadata = {
-                creationDate: Date.now(),
-                owner: "default",
-              };
-            }
-
-            buckets.push({
-              name: entry.name,
-              creationDate: metadata.creationDate,
-            });
-          } catch (error) {
-            console.error(`读取存储桶 ${entry.name} 的元数据时出错:`, error);
-          }
-        }
-      }
-
-      return buckets;
-    } catch (error) {
-      console.error("列出存储桶时出错:", error);
-      return [];
-    }
-  }
-
-  /**
-   * 获取对象信息
-   * @param {string} objectPath - 对象路径（格式：/bucket/key）
-   * @returns {Promise<Object|null>} 对象信息或null（如果不存在）
-   */
-  async stat(objectPath) {
-    try {
-      const fullPath = this.getObjectPath(objectPath);
-      const stats = await fs.stat(fullPath);
-
-      return {
-        size: stats.size,
-        mtime: stats.mtime.getTime(),
-        isDirectory: stats.isDirectory(),
-        uuid: crypto.createHash("md5").update(fullPath).digest("hex"),
-      };
-    } catch (error) {
-      return null;
-    }
-  }
-
-  /**
-   * 读取目录内容
-   * @param {string} dirPath - 目录路径（格式：/bucket/key）
-   * @returns {Promise<Array>} 目录内容列表
-   */
-  async readdir(dirPath) {
-    try {
-      const fullPath = this.getObjectPath(dirPath);
-      const entries = await fs.readdir(fullPath);
-
-      // 过滤掉元数据文件
-      return entries.filter((entry) => !entry.startsWith("."));
-    } catch (error) {
-      return [];
-    }
-  }
-
-  /**
-   * 创建读取流
-   * @param {string} objectPath - 对象路径（格式：/bucket/key）
-   * @param {Object} options - 选项
-   * @returns {Promise<ReadableStream>} 可读流
-   */
-  async createReadStream(objectPath, options = {}) {
-    const fullPath = this.getObjectPath(objectPath);
-
-    try {
-      // 检查文件是否存在
-      await fs.access(fullPath);
-
-      // 创建读取流
-      return createReadStream(fullPath, options);
-    } catch (error) {
-      // 如果文件不存在，返回空流
-      const emptyStream = new Readable();
-      emptyStream.push(null);
-      return emptyStream;
-    }
-  }
-
-  /**
-   * 创建写入流
-   * @param {string} objectPath - 对象路径（格式：/bucket/key）
-   * @returns {Promise<WritableStream>} 可写流
-   */
-  async createWriteStream(objectPath) {
-    const fullPath = this.getObjectPath(objectPath);
-
-    // 确保父目录存在
-    const dirPath = path.dirname(fullPath);
-    await this.ensureDir(dirPath);
-
-    // 创建写入流
-    return createWriteStream(fullPath);
-  }
-
-  /**
-   * 删除对象
-   * @param {string} objectPath - 对象路径（格式：/bucket/key）
-   * @returns {Promise<void>}
-   */
-  async unlink(objectPath) {
-    const fullPath = this.getObjectPath(objectPath);
-    await fs.unlink(fullPath);
-  }
-
-  /**
-   * 更新对象元数据
-   * @param {string} objectPath - 对象路径（格式：/bucket/key）
-   * @param {Object} metadata - 元数据
-   * @returns {Promise<void>}
-   */
-  async updateObjectMetadata(objectPath, metadata) {
-    const fullPath = this.getObjectPath(objectPath);
-    const metadataPath = `${fullPath}.metadata.json`;
-
-    try {
-      // 读取现有元数据（如果存在）
-      let existingMetadata = {};
-
-      try {
-        const data = await fs.readFile(metadataPath, "utf8");
-        existingMetadata = JSON.parse(data);
-      } catch (error) {
-        // 如果元数据文件不存在或无效，使用空对象
-      }
-
-      // 合并元数据
-      const updatedMetadata = {
-        ...existingMetadata,
-        ...metadata,
-        lastModified: new Date().toISOString(),
-      };
-
-      // 写入元数据文件
-      await fs.writeFile(
-        metadataPath,
-        JSON.stringify(updatedMetadata, null, 2),
-      );
-    } catch (error) {
-      console.error("更新对象元数据时出错:", error);
-    }
-  }
-
-  /**
-   * 获取对象元数据
-   * @param {string} objectPath - 对象路径（格式：/bucket/key）
-   * @returns {Promise<Object|null>} 元数据或null（如果不存在）
-   */
-  async getObjectMetadata(objectPath) {
-    const fullPath = this.getObjectPath(objectPath);
-    const metadataPath = `${fullPath}.metadata.json`;
-
-    try {
-      const data = await fs.readFile(metadataPath, "utf8");
-      return JSON.parse(data);
-    } catch (error) {
-      return null;
-    }
-  }
-}
-
-module.exports = S3Driver;

package/handlers/createBucket.js

@@ -1,129 +0,0 @@
-const Responses = require("../responses");
-
-/**
- * 处理S3 CreateBucket请求
- * 创建新的存储桶
- */
-class CreateBucket {
-  constructor(server) {
-    this.server = server;
-    this.handle = this.handle.bind(this);
-  }
-
-  /**
-   * 处理CreateBucket请求
-   * @param {object} req - Express请求对象
-   * @param {object} res - Express响应对象
-   */
-  async handle(req, res) {
-    try {
-      // 获取存储桶名称
-      const { bucket } = this.extractBucketAndKey(req);
-
-      if (!bucket) {
-        await Responses.error(
-          res,
-          400,
-          "InvalidBucketName",
-          "无效的存储桶名称",
-        );
-        return;
-      }
-
-      // 验证存储桶名称
-      if (!this.isValidBucketName(bucket)) {
-        await Responses.error(
-          res,
-          400,
-          "InvalidBucketName",
-          "存储桶名称不符合规范",
-        );
-        return;
-      }
-
-      // 检查存储桶是否已存在
-      const bucketExists = await this.server.driver.bucketExists(bucket);
-
-      if (bucketExists) {
-        // 如果存储桶已存在且属于当前用户，返回200
-        if (await this.server.driver.isBucketOwner(bucket)) {
-          res.set("Location", `/${bucket}`);
-          await Responses.ok(res);
-          return;
-        }
-
-        // 如果存储桶已存在但不属于当前用户，返回409
-        await Responses.error(
-          res,
-          409,
-          "BucketAlreadyExists",
-          "存储桶已存在且不属于您",
-        );
-        return;
-      }
-
-      // 创建存储桶
-      await this.server.driver.createBucket(bucket);
-
-      // 设置Location头
-      res.set("Location", `/${bucket}`);
-
-      // 返回成功响应
-      await Responses.ok(res);
-    } catch (error) {
-      console.error("Error in CreateBucket:", 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 {string} name - 存储桶名称
-   * @returns {boolean} 是否有效
-   */
-  isValidBucketName(name) {
-    // 存储桶命名规则：
-    // - 3到63个字符
-    // - 只能包含小写字母、数字和连字符
-    // - 必须以字母或数字开头和结尾
-    // - 不能是IP地址格式
-
-    if (!name || name.length < 3 || name.length > 63) {
-      return false;
-    }
-
-    // 检查是否只包含有效字符
-    if (!/^[a-z0-9][a-z0-9.-]*[a-z0-9]$/.test(name)) {
-      return false;
-    }
-
-    // 检查是否是IP地址格式
-    if (/^\d+\.\d+\.\d+\.\d+$/.test(name)) {
-      return false;
-    }
-
-    // 检查是否包含连续的点或连字符
-    if (name.includes("..") || name.includes(".-") || name.includes("-.")) {
-      return false;
-    }
-
-    return true;
-  }
-}
-
-module.exports = CreateBucket;

package/handlers/deleteBucket.js

@@ -1,84 +0,0 @@
-const Responses = require("../responses");
-
-/**
- * 处理S3 DeleteBucket请求
- * 删除存储桶
- */
-class DeleteBucket {
-  constructor(server) {
-    this.server = server;
-    this.handle = this.handle.bind(this);
-  }
-
-  /**
-   * 处理DeleteBucket请求
-   * @param {object} req - Express请求对象
-   * @param {object} res - Express响应对象
-   */
-  async handle(req, res) {
-    try {
-      // 获取存储桶名称
-      const { bucket } = this.extractBucketAndKey(req);
-
-      if (!bucket) {
-        await Responses.error(
-          res,
-          400,
-          "InvalidBucketName",
-          "无效的存储桶名称",
-        );
-        return;
-      }
-
-      // 检查存储桶是否存在
-      const bucketExists = await this.server.driver.bucketExists(bucket);
-
-      if (!bucketExists) {
-        await Responses.error(res, 404, "NoSuchBucket", "存储桶不存在");
-        return;
-      }
-
-      // 检查存储桶是否为空
-      const isEmpty = await this.server.driver.isBucketEmpty(bucket);
-
-      if (!isEmpty) {
-        await Responses.error(res, 409, "BucketNotEmpty", "存储桶不为空");
-        return;
-      }
-
-      // 检查是否有权限删除存储桶
-      const isOwner = await this.server.driver.isBucketOwner(bucket);
-
-      if (!isOwner) {
-        await Responses.error(res, 403, "AccessDenied", "没有权限删除此存储桶");
-        return;
-      }
-
-      // 删除存储桶
-      await this.server.driver.deleteBucket(bucket);
-
-      // 返回成功响应
-      await Responses.noContent(res);
-    } catch (error) {
-      console.error("Error in DeleteBucket:", 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 = DeleteBucket;