@vryzel/file-next 0.5.2 → 0.6.0

package/dist/server/index.cjs

@@ -160,13 +160,44 @@ var FileSystemError = class extends Error {
 var asS3Key = (s) => s;
 var asTenantId = (s) => s;
 
+// src/storage/content-disposition.ts
+var NEVER_INLINE = /* @__PURE__ */ new Set(["text/html", "application/xhtml+xml", "image/svg+xml"]);
+var DENIED_UPLOAD = /* @__PURE__ */ new Set([
+  "text/html",
+  "application/xhtml+xml",
+  "image/svg+xml",
+  "text/xml",
+  "application/xml"
+]);
+function mimeBase(contentType) {
+  return (contentType ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+}
+function isDeniedUploadType(contentType) {
+  return DENIED_UPLOAD.has(mimeBase(contentType));
+}
+function matchesAllowedContentType(pattern, actual) {
+  const mime = mimeBase(actual);
+  if (!mime || isDeniedUploadType(mime)) return false;
+  if (pattern === mime) return true;
+  if (pattern.endsWith("/*")) return mime.startsWith(pattern.slice(0, -1));
+  return false;
+}
+function signedContentDisposition(requested, contentType) {
+  const mime = (contentType ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+  if (!mime || NEVER_INLINE.has(mime)) return "attachment";
+  if (mime === "application/pdf" || mime === "text/plain" || mime === "text/csv" || mime === "text/markdown" || mime.startsWith("image/") || mime.startsWith("video/") || mime.startsWith("audio/")) {
+    return "inline";
+  }
+  return "attachment";
+}
+
 // src/server/actions.ts
 var NodeIdSchema = zod.z.string().min(1, "id is required");
 var PathSchema = zod.z.string().nullable();
 var ListFilesInputSchema = zod.z.object({
   parentId: PathSchema,
-  limit: zod.z.number().int().positive().optional(),
-  cursor: zod.z.string().optional()
+  limit: zod.z.number().int().positive().max(500).optional(),
+  cursor: zod.z.string().max(256).optional()
 });
 var DeleteFileInputSchema = zod.z.object({
   id: NodeIdSchema,
@@ -184,7 +215,7 @@ var CopyFileInputSchema = zod.z.object({
 });
 var SetMetadataInputSchema = zod.z.object({
   id: NodeIdSchema,
-  metadata: zod.z.record(zod.z.string()),
+  metadata: zod.z.record(zod.z.string(), zod.z.string()),
   replace: zod.z.boolean().optional()
 });
 var CreateFolderInputSchema = zod.z.object({
@@ -205,9 +236,13 @@ var ConfirmUploadInputSchema = zod.z.object({
   size: zod.z.number().int().nonnegative().optional()
 });
 var SearchFilesInputSchema = zod.z.object({
-  query: zod.z.string(),
-  parentId: zod.z.string().optional(),
-  limit: zod.z.number().int().positive().optional()
+  query: zod.z.string().max(256),
+  parentId: zod.z.string().max(256).optional(),
+  limit: zod.z.number().int().positive().max(500).optional()
+});
+var ListTrashInputSchema = zod.z.object({
+  limit: zod.z.number().int().positive().max(500).optional(),
+  cursor: zod.z.string().max(256).optional()
 });
 var RestoreNodeInputSchema = zod.z.object({
   id: NodeIdSchema
@@ -236,7 +271,7 @@ var createServerActions = (deps) => {
     if (e instanceof FileSystemError) return e;
     return new FileSystemError({
       code,
-      message: `${message}: ${e instanceof Error ? e.message : String(e)}`,
+      message,
       retryable: true
     });
   };
@@ -337,12 +372,34 @@ var createServerActions = (deps) => {
   const prepareUpload = async (input) => {
     const parsed = PrepareUploadInputSchema.safeParse(input);
     if (!parsed.success) return zodErr("Invalid prepareUpload input", parsed);
+    const maxBytes = deps.maxBytes ?? fs.maxBytes;
+    if (maxBytes != null && parsed.data.contentLength > maxBytes) {
+      return err(
+        new FileSystemError({
+          code: "PayloadTooLarge",
+          message: `contentLength exceeds maxBytes ${maxBytes}`,
+          retryable: false
+        })
+      );
+    }
+    if (isDeniedUploadType(parsed.data.contentType) || deps.allowedContentTypes != null && !deps.allowedContentTypes.some(
+      (pattern) => matchesAllowedContentType(pattern, parsed.data.contentType)
+    )) {
+      return err(
+        new FileSystemError({
+          code: "UnsupportedMediaType",
+          message: "Content type is not allowed",
+          retryable: false
+        })
+      );
+    }
     try {
       const auth = await authTenant();
       const id = typeof globalThis.crypto?.randomUUID === "function" ? globalThis.crypto.randomUUID() : `upl-${Date.now()}`;
       const signed = await fs.forTenant(auth.tenantId).adapter.createPresignedUploadUrl({
         key: asS3Key(id),
         contentType: parsed.data.contentType,
+        contentLength: parsed.data.contentLength,
         expiresIn: 900
       });
       if (!signed.ok) return signed;
@@ -392,12 +449,14 @@ var createServerActions = (deps) => {
     }
   };
   const listTrash = async (input = {}) => {
+    const parsed = ListTrashInputSchema.safeParse(input);
+    if (!parsed.success) return zodErr("Invalid listTrash input", parsed);
     try {
       const auth = await authTenant();
       return store.listTrash({
         tenantId: asTenantId(auth.tenantId),
-        limit: input.limit,
-        cursor: input.cursor
+        limit: parsed.data.limit,
+        cursor: parsed.data.cursor
       });
     } catch (e) {
       return err(wrap(e, "InternalError", "listTrash failed"));
@@ -499,18 +558,12 @@ var createServerActions = (deps) => {
     revokeShare
   };
 };
-
-// src/server/route-handlers/upload.ts
 var MAX_EXPIRES_IN_SECONDS = 7 * 24 * 60 * 60;
 var DEFAULT_EXPIRES_IN_SECONDS = 900;
-var matchesContentType = (pattern, actual) => {
-  if (pattern === actual) return true;
-  if (pattern.endsWith("/*")) {
-    const prefix = pattern.slice(0, -1);
-    return actual.startsWith(prefix);
-  }
-  return false;
-};
+var UploadBody = zod.z.object({
+  contentType: zod.z.string().min(1).max(255),
+  contentLength: zod.z.number().int().nonnegative()
+});
 var assertExpiresIn = (expiresIn) => {
   if (!Number.isFinite(expiresIn) || expiresIn < 1 || expiresIn > MAX_EXPIRES_IN_SECONDS) {
     throw new FileSystemError({
@@ -522,65 +575,76 @@ var assertExpiresIn = (expiresIn) => {
   }
 };
 var createUploadRouteHandler = (opts) => {
+  if (!opts.getAuth && opts.unsafeNoAuth !== true) {
+    throw new Error("file-next: getAuth is required");
+  }
   const expiresIn = opts.expiresIn ?? DEFAULT_EXPIRES_IN_SECONDS;
   assertExpiresIn(expiresIn);
   return async (req) => {
-    let body;
+    let fs = opts.fs;
+    if (opts.getAuth) {
+      const auth = await opts.getAuth(req);
+      if (!auth) {
+        return Response.json(
+          { ok: false, error: { code: "Unauthorized", message: "Not authenticated" } },
+          { status: 401 }
+        );
+      }
+      fs = opts.fs.forTenant(auth.tenantId);
+    }
+    let raw;
     try {
-      body = await req.json();
+      raw = await req.json();
     } catch {
       return Response.json(
         { ok: false, error: { code: "InternalError", message: "Request body must be valid JSON" } },
         { status: 400 }
       );
     }
+    const parsed = UploadBody.safeParse(raw);
+    if (!parsed.success) {
+      return Response.json(
+        { ok: false, error: { code: "InternalError", message: "Invalid upload request" } },
+        { status: 400 }
+      );
+    }
+    const body = parsed.data;
     if (typeof opts.maxBytes === "number" && body.contentLength > opts.maxBytes) {
       return Response.json(
         {
           ok: false,
           error: {
             code: "PayloadTooLarge",
-            message: `contentLength ${body.contentLength} exceeds maxBytes ${opts.maxBytes}`
+            message: `contentLength exceeds maxBytes ${opts.maxBytes}`
           }
         },
         { status: 413 }
       );
     }
-    if (opts.allowedContentTypes && opts.allowedContentTypes.length > 0) {
-      const allowed = opts.allowedContentTypes.some((p) => matchesContentType(p, body.contentType));
-      if (!allowed) {
-        return Response.json(
-          {
-            ok: false,
-            error: {
-              code: "UnsupportedMediaType",
-              message: `contentType "${body.contentType}" is not in the allowed list`
-            }
-          },
-          { status: 415 }
-        );
-      }
-    }
-    let fs = opts.fs;
-    if (opts.getAuth) {
-      const auth = await opts.getAuth(req);
-      if (!auth) {
-        return Response.json(
-          { ok: false, error: { code: "Unauthorized", message: "Not authenticated" } },
-          { status: 401 }
-        );
-      }
-      fs = opts.fs.forTenant(auth.tenantId);
+    if (isDeniedUploadType(body.contentType) || opts.allowedContentTypes && opts.allowedContentTypes.length > 0 && !opts.allowedContentTypes.some(
+      (pattern) => matchesAllowedContentType(pattern, body.contentType)
+    )) {
+      return Response.json(
+        {
+          ok: false,
+          error: {
+            code: "UnsupportedMediaType",
+            message: "Content type is not allowed"
+          }
+        },
+        { status: 415 }
+      );
     }
     const id = typeof globalThis.crypto?.randomUUID === "function" ? globalThis.crypto.randomUUID() : `upl-${Date.now()}`;
     const r = await fs.adapter.createPresignedUploadUrl({
       key: asS3Key(id),
       contentType: body.contentType,
+      contentLength: body.contentLength,
       expiresIn
     });
     if (!r.ok) {
       return Response.json(
-        { ok: false, error: { code: r.error.code, message: r.error.message } },
+        { ok: false, error: { code: r.error.code, message: "Upload failed" } },
         { status: 500 }
       );
     }
@@ -613,9 +677,28 @@ var assertExpiresIn2 = (expiresIn) => {
   }
 };
 var createDownloadRouteHandler = (opts) => {
+  if (!opts.getAuth && opts.unsafeNoAuth !== true) {
+    throw new Error("file-next: getAuth is required");
+  }
+  if (opts.getAuth && !opts.store) {
+    throw new Error("file-next: store is required when getAuth is set");
+  }
   const expiresIn = opts.expiresIn ?? DEFAULT_EXPIRES_IN_SECONDS2;
   assertExpiresIn2(expiresIn);
   return async (req) => {
+    let fs = opts.fs;
+    let tenantId;
+    if (opts.getAuth) {
+      const auth = await opts.getAuth(req);
+      if (!auth) {
+        return Response.json(
+          { ok: false, error: { code: "Unauthorized", message: "Not authenticated" } },
+          { status: 401 }
+        );
+      }
+      tenantId = auth.tenantId;
+      fs = opts.fs.forTenant(auth.tenantId);
+    }
     const url = new URL(req.url);
     const key = url.searchParams.get("key");
     if (!key) {
@@ -624,16 +707,17 @@ var createDownloadRouteHandler = (opts) => {
         { status: 400 }
       );
     }
-    let fs = opts.fs;
-    if (opts.getAuth) {
-      const auth = await opts.getAuth(req);
-      if (!auth) {
+    if (opts.store && tenantId) {
+      const node = await opts.store.findByS3Key({
+        tenantId: asTenantId(tenantId),
+        s3Key: key
+      });
+      if (!node.ok || !node.value) {
         return Response.json(
-          { ok: false, error: { code: "Unauthorized", message: "Not authenticated" } },
-          { status: 401 }
+          { ok: false, error: { code: "NotFound", message: "Not found" } },
+          { status: 404 }
         );
       }
-      fs = opts.fs.forTenant(auth.tenantId);
     }
     const r = await fs.adapter.createPresignedDownloadUrl({
       key: asS3Key(key),
@@ -641,7 +725,7 @@ var createDownloadRouteHandler = (opts) => {
     });
     if (!r.ok) {
       return Response.json(
-        { ok: false, error: { code: r.error.code, message: r.error.message } },
+        { ok: false, error: { code: r.error.code, message: "Download failed" } },
         { status: 500 }
       );
     }
@@ -653,18 +737,17 @@ var createDownloadRouteHandler = (opts) => {
   };
 };
 
-// src/storage/content-disposition.ts
-var NEVER_INLINE = /* @__PURE__ */ new Set(["text/html", "application/xhtml+xml", "image/svg+xml"]);
-function signedContentDisposition(requested, contentType) {
-  const mime = (contentType ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
-  if (!mime || NEVER_INLINE.has(mime)) return "attachment";
-  if (mime === "application/pdf" || mime === "text/plain" || mime === "text/csv" || mime === "text/markdown" || mime.startsWith("image/") || mime.startsWith("video/") || mime.startsWith("audio/")) {
-    return "inline";
-  }
-  return "attachment";
-}
-
 // src/server/route-handlers/share.ts
+var DEFAULT_MAX_SHARE_BYTES = 32 * 1024 * 1024;
+var shareHeaders = () => {
+  const headers = new Headers();
+  headers.set("X-Content-Type-Options", "nosniff");
+  headers.set("Content-Security-Policy", "sandbox; default-src 'none'");
+  headers.set("Cross-Origin-Resource-Policy", "same-origin");
+  headers.set("Cache-Control", "private, no-store");
+  headers.set("Referrer-Policy", "no-referrer");
+  return headers;
+};
 var tokenFromRequest = (req) => {
   const url = new URL(req.url);
   const query = url.searchParams.get("token");
@@ -686,7 +769,7 @@ var createShareRouteHandler = (opts) => {
     const resolved = await opts.store.resolveShare({ token });
     if (!resolved.ok) {
       return Response.json(
-        { ok: false, error: { code: resolved.error.code, message: resolved.error.message } },
+        { ok: false, error: { code: "InternalError", message: "Share lookup failed" } },
         { status: 500 }
       );
     }
@@ -698,29 +781,54 @@ var createShareRouteHandler = (opts) => {
       );
     }
     const adapter = opts.fs.forTenant(node.tenantId).adapter;
-    const rangeHeader = req.headers.get("range") ?? void 0;
+    const download = new URL(req.url).searchParams.get("download") === "1";
+    const key = asS3Key(node.s3Key);
+    const st = await adapter.stat({ key });
+    if (!st.ok) {
+      return Response.json(
+        { ok: false, error: { code: "NotFound", message: "Share not found" } },
+        { status: 404 }
+      );
+    }
+    const maxBytes = opts.maxBytes ?? DEFAULT_MAX_SHARE_BYTES;
+    if (st.value.size > maxBytes) {
+      const signed = await adapter.createPresignedDownloadUrl({
+        key,
+        expiresIn: 60,
+        disposition: download ? "attachment" : "inline",
+        contentType: st.value.contentType || node.mimeType
+      });
+      if (!signed.ok) {
+        return Response.json(
+          { ok: false, error: { code: "InternalError", message: "Share failed" } },
+          { status: 500 }
+        );
+      }
+      const headers2 = shareHeaders();
+      headers2.set("Location", signed.value.url);
+      return new Response(null, { status: 302, headers: headers2 });
+    }
     const read = await adapter.read({
-      key: asS3Key(node.s3Key),
-      range: rangeHeader ?? void 0
+      key,
+      range: req.headers.get("range") ?? void 0
     });
     if (!read.ok) {
       return Response.json(
-        { ok: false, error: { code: read.error.code, message: read.error.message } },
+        { ok: false, error: { code: "NotFound", message: "Share not found" } },
         { status: 404 }
       );
     }
-    const download = new URL(req.url).searchParams.get("download") === "1";
-    const headers = new Headers();
-    const mime = node.mimeType || read.value.contentType || "application/octet-stream";
+    const headers = shareHeaders();
+    const mime = st.value.contentType || node.mimeType || read.value.contentType || "application/octet-stream";
     headers.set("Content-Type", mime);
     const disposition = download ? "attachment" : signedContentDisposition("inline", mime);
     headers.set(
       "Content-Disposition",
       `${disposition}; filename*=UTF-8''${encodeURIComponent(node.name)}`
     );
-    headers.set("Cache-Control", "private, no-store");
-    headers.set("Content-Length", String(read.value.body.byteLength));
-    return new Response(Buffer.from(read.value.body), { status: 200, headers });
+    const bytes = Uint8Array.from(read.value.body);
+    headers.set("Content-Length", String(bytes.byteLength));
+    return new Response(bytes.buffer, { status: 200, headers });
   };
 };