@filebox/webdav-server 1.0.0 → 1.0.1

package/dist/index.cjs

@@ -0,0 +1,621 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  WebDAVServer: () => WebDAVServer,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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
+var import_pathe = require("pathe");
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var put_default = async (ctx) => {
+  try {
+    const rawPath = decodeURIComponent(ctx.path);
+    const name = (0, import_pathe.basename)(rawPath);
+    const upath = (0, import_pathe.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 = import_node_path.default.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 = import_node_fs.default.createWriteStream(tempFile);
+        uploadStream.pipe(ws);
+        ws.on("finish", resolve);
+        ws.on("error", reject);
+        uploadStream.on("error", reject);
+      });
+    } else {
+      import_node_fs.default.writeFileSync(tempFile, "");
+    }
+    const tempStat = import_node_fs.default.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 {
+        import_node_fs.default.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
+var import_pathe2 = require("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, (0, import_pathe2.basename)(normalizedDst));
+    } else {
+      await ctx.driver?.move(normalizedSrc, (0, import_pathe2.dirname)(normalizedDst));
+    }
+    return {
+      status: "201"
+    };
+  } catch (_) {
+    return {
+      status: "502",
+      body: null
+    };
+  }
+};
+
+// src/operations/copy.ts
+var import_pathe3 = require("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 = (0, import_pathe3.dirname)(dst);
+    const name = (0, import_pathe3.basename)(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
+var import_xml2js2 = __toESM(require("xml2js"), 1);
+
+// src/operations/shared.ts
+var import_xml2js = require("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 (0, import_xml2js.parseStringPromise)(txt, {
+    // explicitChildren: true,
+    explicitArray: false,
+    tagNameProcessors: [import_xml2js.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 import_xml2js2.default.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
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebDAVServer
+});

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+export interface WebDAVServerOptions {
+  driver?: unknown;
+  base?: string;
+  redirect?: boolean;
+  auth?: (user?: string, pass?: string) => boolean | Promise<boolean>;
+}
+
+export interface WebDAVRequestOptions {
+  base?: string;
+  driver?: unknown;
+  temp?: string;
+}
+
+export interface WebDAVResponse {
+  status?: string | number;
+  headers?: Record<string, string>;
+  body?: unknown;
+}
+
+export class WebDAVServer {
+  constructor(options?: WebDAVServerOptions);
+  request(req: unknown, options: WebDAVRequestOptions): Promise<WebDAVResponse>;
+}
+
+declare const api: {
+  WebDAVServer: typeof WebDAVServer;
+};
+
+export default api;