@filebox/webdav-server 1.0.0 → 1.0.1

package/dist/index.mjs

@@ -0,0 +1,591 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/operations/commands.ts
+var commands_exports = {};
+__export(commands_exports, {
+  Copy: () => copy_default,
+  Delete: () => delete_default,
+  Get: () => get_default,
+  Head: () => head_default,
+  Mkcol: () => mkcol_default,
+  Move: () => move_default,
+  NotImplemented: () => not_implemented_default,
+  Options: () => options_default,
+  Propfind: () => propfind_default,
+  Proppatch: () => proppatch_default,
+  Put: () => put_default
+});
+
+// src/operations/get.ts
+async function loadProxy() {
+  const proxy = await import("@filebox/proxy");
+  return proxy.default || proxy;
+}
+var get_default = async (ctx) => {
+  try {
+    const decodedPath = decodeURIComponent(ctx.path);
+    const stat = await ctx.driver.stat(decodedPath);
+    if (!stat || !stat.file) {
+      return {
+        status: "405",
+        body: "405 Method not allowed"
+      };
+    }
+    const data = await ctx.driver.download(decodedPath);
+    if (!data || !data.length || !data[0].url) {
+      return {
+        status: "404",
+        body: "file not found"
+      };
+    }
+    const proxy = await loadProxy();
+    return proxy(ctx.req, {
+      ...data[0],
+      fileName: decodedPath
+    });
+  } catch (_) {
+    return {
+      status: "500",
+      body: "Internal Server Error"
+    };
+  }
+};
+
+// src/operations/put.ts
+import { basename, dirname } from "pathe";
+import fs from "node:fs";
+import path from "node:path";
+var put_default = async (ctx) => {
+  try {
+    const rawPath = decodeURIComponent(ctx.path);
+    const name = basename(rawPath);
+    const upath = dirname(rawPath);
+    const contentLength = parseInt(ctx.req.headers["content-length"] || 0);
+    const mimeType = ctx.req.headers["content-type"] || "application/octet-stream";
+    const tempDir = ctx.config?.temp;
+    if (!tempDir) {
+      return { status: "500", body: "temp dir not configured" };
+    }
+    const tempFile = path.join(tempDir, `webdav-upload-${Date.now()}-${name}`);
+    const uploadStream = ctx.req._webdavStream || (ctx.req.readable && !ctx.req.readableEnded ? ctx.req : null);
+    if (uploadStream && contentLength > 0) {
+      await new Promise((resolve, reject) => {
+        const ws = fs.createWriteStream(tempFile);
+        uploadStream.pipe(ws);
+        ws.on("finish", resolve);
+        ws.on("error", reject);
+        uploadStream.on("error", reject);
+      });
+    } else {
+      fs.writeFileSync(tempFile, "");
+    }
+    const tempStat = fs.statSync(tempFile);
+    if (tempStat.size === 0 && contentLength > 0) {
+      return { status: "502", body: "upload failed: empty file" };
+    }
+    try {
+      const result = await ctx.driver.upload(upath, {
+        name,
+        size: tempStat.size,
+        absolutePath: tempFile,
+        mimeType
+      });
+      if (result && typeof result.upload === "function") {
+        await result.upload();
+      }
+    } catch (error) {
+      return { status: "502", body: String(error) };
+    } finally {
+      try {
+        fs.unlinkSync(tempFile);
+      } catch (_) {
+      }
+    }
+    return { status: "200" };
+  } catch (err) {
+    return { status: "502", body: String(err?.message || err) };
+  }
+};
+
+// src/operations/head.ts
+var head_default = async (ctx) => {
+  try {
+    console.log(ctx.path, "head", 22222);
+    const stat = ctx.driver.stat(ctx.path);
+    const headers = {
+      "Content-Type": "application/octet-stream",
+      "Content-Length": stat.size,
+      "Last-Modified": stat.mtime,
+      "Accept-Ranges": "bytes"
+    };
+    return {
+      status: "200",
+      headers,
+      body: null
+    };
+  } catch (error) {
+    console.log(error);
+    return {
+      status: "404"
+    };
+  }
+};
+
+// src/operations/move.ts
+import { basename as basename2, dirname as dirname2 } from "pathe";
+var move_default = async (ctx) => {
+  try {
+    const dst = new URL(ctx.req.headers?.destination).pathname.replace(
+      ctx.base,
+      ""
+    );
+    const src = ctx.path;
+    if (!dst) {
+      return {
+        status: "400",
+        body: "Missing source or destination URI"
+      };
+    }
+    const normalizedSrc = src.endsWith("/") ? src.slice(0, -1) : src;
+    const normalizedDst = dst.endsWith("/") ? dst.slice(0, -1) : dst;
+    if (normalizedSrc === normalizedDst) {
+      return { status: "403" };
+    }
+    const isRename = normalizedSrc.substring(0, normalizedSrc.lastIndexOf("/")) === normalizedDst.substring(0, normalizedDst.lastIndexOf("/"));
+    if (isRename) {
+      await ctx.driver?.rename(normalizedSrc, basename2(normalizedDst));
+    } else {
+      await ctx.driver?.move(normalizedSrc, dirname2(normalizedDst));
+    }
+    return {
+      status: "201"
+    };
+  } catch (_) {
+    return {
+      status: "502",
+      body: null
+    };
+  }
+};
+
+// src/operations/copy.ts
+import { basename as basename3, dirname as dirname3 } from "pathe";
+var copy_default = async (ctx) => {
+  try {
+    const dst = new URL(ctx.req.headers?.destination).pathname.replace(
+      ctx.base,
+      ""
+    );
+    const src = ctx.path;
+    if (src === dst) {
+      return { status: "403" };
+    }
+    const stat = await ctx.driver.stat(src);
+    if (!stat || !stat.file) {
+      return { status: "404" };
+    }
+    const data = await ctx.driver.download(src);
+    if (!data || !data.length) {
+      return { status: "404" };
+    }
+    const upath = dirname3(dst);
+    const name = basename3(dst);
+    const resp = await fetch(data[0].url);
+    await ctx.driver.upload(upath, {
+      name,
+      size: parseInt(resp.headers.get("content-length") || "0"),
+      data: resp.body,
+      mimeType: stat.mime || "application/octet-stream"
+    });
+    return { status: "201" };
+  } catch (_) {
+    return { status: "502" };
+  }
+};
+
+// src/operations/mkcol.ts
+var mkcol_default = async (ctx) => {
+  try {
+    await ctx.driver.mkdir(ctx.path);
+    return {
+      status: "201",
+      body: null
+    };
+  } catch (_) {
+    return {
+      status: "500",
+      body: null
+    };
+  }
+};
+
+// src/operations/delete.ts
+var delete_default = async (ctx) => {
+  try {
+    await ctx.driver.remove(ctx.path);
+    return {
+      status: "204"
+    };
+  } catch (_) {
+    return {
+      status: "502"
+    };
+  }
+};
+
+// src/operations/options.ts
+var options_default = async (ctx) => {
+  const dav = [1];
+  if (ctx.allows?.includes("LOCK")) {
+    dav.push(2);
+  }
+  return {
+    headers: {
+      // For Microsoft clients
+      "MS-Author-Via": "DAV",
+      DAV: dav.join(", "),
+      Allow: ctx.allows?.join(", ") || ""
+    },
+    status: "200"
+  };
+};
+
+// src/operations/propfind.ts
+import xml2js from "xml2js";
+
+// src/operations/shared.ts
+import { parseStringPromise, processors } from "xml2js";
+var parseBody = (req, charset) => {
+  return new Promise((resolve, reject) => {
+    const data = [];
+    const stream = req._webdavStream || req;
+    stream.on("data", (chunk) => {
+      data.push(chunk);
+    }).on("error", reject).on("end", () => resolve(Buffer.concat(data).toString(charset)));
+  });
+};
+var parseXML = async (req) => {
+  const txt = await parseBody(req);
+  if (!txt.trim()) return null;
+  return await parseStringPromise(txt, {
+    // explicitChildren: true,
+    explicitArray: false,
+    tagNameProcessors: [processors.stripPrefix]
+  });
+};
+var shared_default = parseXML;
+
+// src/operations/propfind.ts
+var DEFAULT_PROPS = [
+  "displayname",
+  "getcontentlength",
+  "resourcetype",
+  "getcontenttype",
+  "creationdate",
+  "getlastmodified"
+];
+var propParse = (data) => {
+  if (!data) {
+    return {
+      ns: { prefix: "D", uri: "DAV:" },
+      prop: [...DEFAULT_PROPS]
+    };
+  }
+  let prop = [...DEFAULT_PROPS];
+  const ns = { prefix: "D", uri: "DAV:" };
+  if (data.propfind.hasOwnProperty("prop")) {
+    if (data.propfind.prop.hasOwnProperty("allprop")) {
+      return {
+        ns,
+        prop: [...DEFAULT_PROPS]
+      };
+    }
+    prop = Object.keys(data.propfind.prop);
+  }
+  return { ns, prop };
+};
+var convData = (files, options) => {
+  const {
+    path: path2,
+    base = "",
+    depth,
+    prop,
+    ns: { prefix, uri }
+  } = options;
+  files = files.data || files.list || files;
+  return files.map((file) => {
+    const item = {};
+    for (const key of prop) {
+      if (key === "displayname") {
+        item[key] = file.name.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+      }
+      if (key === "getcontentlength") {
+        item[key] = file.byte || 0;
+      }
+      if (key === "resourcetype") {
+        item[key] = file.type === "folder" ? { collection: "" } : "";
+      }
+      if (key == "getcontenttype") {
+        item[key] = file.mime;
+      }
+      if (key === "getetag") {
+        const stamp = file.etag || file.hash || file.mtime || file.updatedAt || "";
+        item[key] = `"${Buffer.from(`${file.name || ""}:${file.byte || 0}:${stamp}`).toString("base64url")}"`;
+      }
+      if (key === "creationdate" && file.ctime) {
+        item[key] = new Date(file.ctime).toUTCString();
+      }
+      if (key === "getlastmodified" && file.mtime) {
+        item[key] = new Date(file.mtime).toUTCString();
+      }
+      if (key === "quota-available-bytes") {
+        item[key] = -1;
+      }
+      if (key === "quota-used-bytes") {
+        item[key] = -1;
+      }
+    }
+    const isSelf = file._self === true;
+    let href = (isSelf ? base + path2 : base + path2 + "/" + encodeURIComponent(file.name)).replace(/\/{2,}/g, "/");
+    if (file.type === "folder" && !href.endsWith("/")) href += "/";
+    return {
+      href,
+      propstat: {
+        status: "HTTP/1.1 200 OK",
+        prop: item
+      }
+    };
+  });
+};
+var fixNs = (data, prefix) => {
+  if (!prefix) return data;
+  Object.keys(data).forEach((key) => {
+    const val = data[key];
+    if (key != "$" && prefix) {
+      if (Array.isArray(val) || typeof val == "object") {
+        fixNs(val, prefix);
+      }
+      delete data[key];
+      data[`${prefix}:${key}`] = val;
+    } else {
+      if (val.xmlns) {
+        val[`xmlns:${prefix}`] = val.xmlns;
+        delete val.xmlns;
+      }
+    }
+  });
+  return data;
+};
+var createXML = (data, options) => {
+  const {
+    ns: { prefix, uri }
+  } = options;
+  const obj = {
+    multistatus: {
+      response: convData(data || [], options)
+    }
+  };
+  if (uri) {
+    obj.multistatus.$ = {
+      xmlns: uri
+    };
+  }
+  const builder = new xml2js.Builder({
+    renderOpts: { pretty: false },
+    xmldec: { version: "1.0", encoding: "UTF-8" }
+  });
+  const xml = builder.buildObject(fixNs(obj, prefix));
+  return xml;
+};
+var propfind_default = async (ctx) => {
+  const options = Object.assign(
+    {
+      path: ctx.path,
+      base: ctx.base,
+      depth: ctx.depth
+    },
+    propParse(await shared_default(ctx.req))
+  );
+  let data = {};
+  data.item = await ctx.driver.stat(ctx.path);
+  if (ctx.depth == "1") {
+    try {
+      data.files = await ctx.driver.list(ctx.path);
+    } catch (error) {
+      return { status: "500" };
+    }
+  }
+  if (!data) return { status: "404" };
+  if (data.error) {
+    if (data.error.code == 401) {
+      return {
+        headers: {
+          "WWW-Authenticate": `Basic realm="ShareList WebDAV"`
+        },
+        status: "401"
+      };
+    } else {
+      return {
+        status: "404"
+      };
+    }
+  }
+  const selfItem = Object.assign({}, data.item, { _self: true });
+  if (ctx.depth == "0") {
+    return {
+      status: "207",
+      headers: {
+        "content-type": 'text/xml; charset="utf-8"'
+      },
+      body: createXML([selfItem], options)
+    };
+  } else if (ctx.depth == "1") {
+    const listResult = data.files;
+    const children = Array.isArray(listResult) ? listResult : Array.isArray(listResult && listResult.data) ? listResult.data : Array.isArray(listResult && listResult.list) ? listResult.list : [];
+    return {
+      status: "207",
+      headers: {
+        // "content-type": 'text/xml; charset="utf-8"',
+        "content-type": 'application/xml; charset="utf-8"'
+      },
+      body: createXML([selfItem].concat(children), options)
+    };
+  } else if (ctx.depth == "infinity") {
+    return {
+      status: "404"
+    };
+  }
+};
+
+// src/operations/proppatch.ts
+var proppatch_default = async (ctx) => {
+  return {
+    status: "200"
+  };
+};
+
+// src/operations/not-implemented.ts
+var not_implemented_default = async (ctx) => {
+  return {
+    status: "405 Method not allowed",
+    headers: {
+      Allow: Object.keys(commands_exports).join(", ")
+    }
+  };
+};
+
+// src/context.ts
+var createContext = (req, base, allows, temp) => {
+  const authorization = req.headers?.authorization?.split(" ")[1];
+  const path2 = new URL(req.url, `http://${req.headers.host}`).pathname;
+  const ctx = {
+    req,
+    depth: req.headers?.depth || 0,
+    method: (req.method || "").toLowerCase(),
+    path: path2.replace(base, "").replace("/k", ""),
+    // 临时这么做
+    base,
+    config: {
+      temp
+    },
+    auth: { user: void 0, pass: void 0 },
+    allows,
+    get(field) {
+      const req2 = this.req;
+      switch (field = field.toLowerCase()) {
+        case "referer":
+        case "referrer":
+          return req2.headers.referrer || req2.headers.referer || "";
+        default:
+          return req2.headers[field] || "";
+      }
+    }
+  };
+  if (authorization) {
+    const pairs = Buffer.from(authorization, "base64").toString("utf8").split(":");
+    ctx.auth = { user: pairs[0], pass: pairs[1] };
+  }
+  return ctx;
+};
+var context_default = createContext;
+
+// src/index.ts
+var StatusCodes = {
+  200: "OK",
+  201: "Created",
+  204: "No Content",
+  207: "Multi Status",
+  302: "Moved Temporarily",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  409: "Conflict",
+  423: "Locked",
+  500: "Internal Server Error"
+};
+var VirtualDriver = {
+  async get() {
+    return {
+      status: "200",
+      body: "Hello World!",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    };
+  }
+  // 其他方法...
+};
+var WebDAVServer = class {
+  constructor({ driver, base, redirect, auth } = { redirect: false, auth: () => true }) {
+    this.methods = {};
+    this.driver = driver || VirtualDriver;
+    this.base = base || "";
+    this.auth = auth;
+    this.config = { redirect };
+    const commands = commands_exports;
+    for (const k in commands) {
+      if (k === "NotImplemented") {
+        this.unknownMethod = commands[k];
+      } else {
+        this.methods[k.toLowerCase()] = commands[k];
+      }
+    }
+    this.allows = Object.keys(this.methods).map((i) => i.toUpperCase());
+  }
+  async request(req, options) {
+    const ctx = context_default(
+      req,
+      options?.base || this.base,
+      this.allows,
+      options.temp
+    );
+    if (!(ctx.method == "options" && !ctx.path) && !this?.auth(ctx.auth.user, ctx.auth.pass)) {
+      return {
+        headers: {
+          "X-WebDAV-Status": `401 ${StatusCodes[401]}`,
+          "www-Authenticate": 'Basic realm="Restricted"'
+        },
+        status: "401"
+      };
+    }
+    ctx.driver = options.driver;
+    ctx.config = { ...this.config, temp: options.temp };
+    const method = this.methods[ctx.method] || this.unknownMethod;
+    const res = await method(ctx);
+    res.headers = res.headers ?? {};
+    if (res.status) {
+    }
+    return res;
+  }
+};
+var index_default = {
+  WebDAVServer
+};
+export {
+  WebDAVServer,
+  index_default as default
+};

package/package.json

@@ -1,28 +1,36 @@
 {
   "name": "@filebox/webdav-server",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "WebDAV 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",
-    "operations",
-    "LICENSE",
-    "README.md"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
   },
   "license": "MIT",
+  "scripts": {
+    "build": "node build.mjs",
+    "prepack": "node build.mjs"
+  },
   "dependencies": {
     "@filebox/proxy": "^1.0.0",
     "pathe": "^1.1.2",
     "xml2js": "^0.6.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.24.0"
   }
 }

package/context.js

@@ -1,37 +0,0 @@
-const createContext = (req, base, allows, temp) => {
-  const authorization = req.headers?.authorization?.split(" ")[1];
-
-  const path = new URL(req.url, `http://${req.headers.host}`).pathname;
-  const ctx = {
-    req: req,
-    depth: req.headers?.depth || 0,
-    method: (req.method || "").toLowerCase(),
-    path: path.replace(base, "").replace("/k", ""), // 临时这么做
-    base,
-    config: {
-      temp,
-    },
-    auth: { user: undefined, pass: undefined },
-    allows,
-    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] || "";
-      }
-    },
-  };
-
-  if (authorization) {
-    const pairs = Buffer.from(authorization, "base64")
-      .toString("utf8")
-      .split(":");
-    ctx.auth = { user: pairs[0], pass: pairs[1] };
-  }
-  return ctx;
-};
-
-module.exports = createContext;