s3kit 0.1.0

package/dist/adapters/next.js

@@ -0,0 +1,775 @@
+// src/adapters/next.ts
+import { S3Client as S3Client2 } from "@aws-sdk/client-s3";
+
+// src/core/manager.ts
+import {
+  CopyObjectCommand,
+  DeleteObjectCommand,
+  DeleteObjectsCommand,
+  ListObjectsV2Command,
+  PutObjectCommand
+} from "@aws-sdk/client-s3";
+import { GetObjectCommand } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+
+// src/core/errors.ts
+var S3FileManagerAuthorizationError = class extends Error {
+  status;
+  code;
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+};
+
+// src/core/manager.ts
+var DEFAULT_DELIMITER = "/";
+function trimSlashes(input) {
+  return input.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function normalizePath(input) {
+  const raw = input.replace(/\\/g, "/");
+  const noLeading = raw.replace(/^\/+/, "");
+  const segments = noLeading.split("/").filter((s) => s.length > 0);
+  for (const seg of segments) {
+    if (seg === "..") {
+      throw new Error("Invalid path");
+    }
+  }
+  return segments.join("/");
+}
+function ensureTrailingDelimiter(prefix, delimiter) {
+  if (prefix === "") return "";
+  return prefix.endsWith(delimiter) ? prefix : `${prefix}${delimiter}`;
+}
+function encodeS3CopySource(bucket, key) {
+  return encodeURIComponent(`${bucket}/${key}`).replace(/%2F/g, "/");
+}
+function isNoSuchKeyError(err) {
+  if (!err || typeof err !== "object") return false;
+  if ("name" in err && err.name === "NoSuchKey") return true;
+  if ("message" in err && typeof err.message === "string") {
+    return err.message.includes("The specified key does not exist");
+  }
+  return false;
+}
+async function* listAllKeys(s3, bucket, prefix) {
+  let cursor;
+  while (true) {
+    const out = await s3.send(
+      new ListObjectsV2Command({
+        Bucket: bucket,
+        Prefix: prefix,
+        ContinuationToken: cursor
+      })
+    );
+    for (const obj of out.Contents ?? []) {
+      if (obj.Key) yield obj.Key;
+    }
+    if (!out.IsTruncated) break;
+    cursor = out.NextContinuationToken;
+  }
+}
+async function deleteKeysInBatches(s3, bucket, keys) {
+  const batchSize = 1e3;
+  for (let i = 0; i < keys.length; i += batchSize) {
+    const batch = keys.slice(i, i + batchSize);
+    await s3.send(
+      new DeleteObjectsCommand({
+        Bucket: bucket,
+        Delete: {
+          Objects: batch.map((Key) => ({ Key })),
+          Quiet: true
+        }
+      })
+    );
+  }
+}
+var S3FileManager = class {
+  s3;
+  bucket;
+  rootPrefix;
+  delimiter;
+  hooks;
+  authorizationMode;
+  constructor(s3, options) {
+    this.s3 = s3;
+    this.bucket = options.bucket;
+    this.delimiter = options.delimiter ?? DEFAULT_DELIMITER;
+    this.rootPrefix = ensureTrailingDelimiter(trimSlashes(options.rootPrefix ?? ""), this.delimiter);
+    this.hooks = options.hooks;
+    this.authorizationMode = options.authorizationMode ?? "deny-by-default";
+  }
+  async authorize(args) {
+    const hasAuthHooks = Boolean(this.hooks?.authorize || this.hooks?.allowAction);
+    if (this.hooks?.authorize) {
+      const result = await this.hooks.authorize(args);
+      if (result === false) {
+        throw new S3FileManagerAuthorizationError("Unauthorized", 401, "unauthorized");
+      }
+    }
+    if (this.hooks?.allowAction) {
+      const allowed = await this.hooks.allowAction(args);
+      if (allowed === false) {
+        throw new S3FileManagerAuthorizationError("Forbidden", 403, "forbidden");
+      }
+    }
+    if (!hasAuthHooks && this.authorizationMode === "deny-by-default") {
+      throw new S3FileManagerAuthorizationError("Unauthorized", 401, "unauthorized");
+    }
+  }
+  pathToKey(path) {
+    const p = normalizePath(path);
+    return `${this.rootPrefix}${p}`;
+  }
+  pathToFolderPrefix(path) {
+    const key = this.pathToKey(path);
+    return ensureTrailingDelimiter(key, this.delimiter);
+  }
+  keyToPath(key) {
+    if (!key.startsWith(this.rootPrefix)) {
+      throw new Error("Key is outside of rootPrefix");
+    }
+    return key.slice(this.rootPrefix.length);
+  }
+  makeFolderEntry(path) {
+    const p = normalizePath(path);
+    const name = p === "" ? "" : p.split("/").at(-1) ?? "";
+    return {
+      type: "folder",
+      path: p === "" ? "" : ensureTrailingDelimiter(p, this.delimiter),
+      name
+    };
+  }
+  makeFileEntryFromKey(key, obj) {
+    const path = this.keyToPath(key);
+    const name = path.split("/").at(-1) ?? "";
+    return {
+      type: "file",
+      path,
+      name,
+      ...obj.Size !== void 0 ? { size: obj.Size } : {},
+      ...obj.LastModified ? { lastModified: obj.LastModified.toISOString() } : {},
+      ...obj.ETag !== void 0 ? { etag: obj.ETag } : {}
+    };
+  }
+  async list(options, ctx = {}) {
+    const path = normalizePath(options.path);
+    await this.authorize({ action: "list", path, ctx });
+    const prefix = path === "" ? this.rootPrefix : this.pathToFolderPrefix(path);
+    const out = await this.s3.send(
+      new ListObjectsV2Command({
+        Bucket: this.bucket,
+        Prefix: prefix,
+        Delimiter: this.delimiter,
+        ContinuationToken: options.cursor,
+        MaxKeys: options.limit
+      })
+    );
+    const folders = (out.CommonPrefixes ?? []).map((cp) => cp.Prefix).filter((p) => typeof p === "string").map((p) => {
+      const rel = this.keyToPath(p);
+      const folderPath = ensureTrailingDelimiter(trimSlashes(rel), this.delimiter);
+      return this.makeFolderEntry(folderPath);
+    });
+    const files = (out.Contents ?? []).filter((obj) => typeof obj.Key === "string").filter((obj) => obj.Key !== prefix).map((obj) => this.makeFileEntryFromKey(obj.Key, obj));
+    for (const folder of folders) {
+      await this.hooks?.decorateFolder?.(folder, {
+        path: folder.path,
+        prefix: this.pathToFolderPrefix(folder.path)
+      });
+    }
+    for (const file of files) {
+      await this.hooks?.decorateFile?.(file, {
+        path: file.path,
+        key: this.pathToKey(file.path)
+      });
+    }
+    const entries = [...folders, ...files].sort((a, b) => {
+      if (a.type !== b.type) return a.type === "folder" ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+    return {
+      path,
+      entries,
+      ...out.IsTruncated && out.NextContinuationToken ? { nextCursor: out.NextContinuationToken } : {}
+    };
+  }
+  async createFolder(options, ctx = {}) {
+    const path = ensureTrailingDelimiter(normalizePath(options.path), this.delimiter);
+    await this.authorize({ action: "folder.create", path, ctx });
+    const key = this.pathToFolderPrefix(path);
+    await this.s3.send(
+      new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+        Body: ""
+      })
+    );
+  }
+  async deleteFolder(options, ctx = {}) {
+    const path = ensureTrailingDelimiter(normalizePath(options.path), this.delimiter);
+    await this.authorize({ action: "folder.delete", path, ctx });
+    const prefix = this.pathToFolderPrefix(path);
+    if (!options.recursive) {
+      const out = await this.s3.send(
+        new ListObjectsV2Command({
+          Bucket: this.bucket,
+          Prefix: prefix,
+          MaxKeys: 2
+        })
+      );
+      const keys2 = (out.Contents ?? []).map((o) => o.Key).filter((k) => typeof k === "string" && k !== prefix);
+      if (keys2.length > 0) {
+        throw new Error("Folder is not empty");
+      }
+      await this.s3.send(new DeleteObjectCommand({ Bucket: this.bucket, Key: prefix }));
+      return;
+    }
+    const keys = [];
+    for await (const key of listAllKeys(this.s3, this.bucket, prefix)) {
+      keys.push(key);
+    }
+    if (keys.length === 0) return;
+    await deleteKeysInBatches(this.s3, this.bucket, keys);
+  }
+  async deleteFiles(options, ctx = {}) {
+    const paths = options.paths.map((p) => normalizePath(p));
+    for (const path of paths) {
+      await this.authorize({ action: "file.delete", path, ctx });
+    }
+    const keys = paths.map((p) => this.pathToKey(p));
+    await deleteKeysInBatches(this.s3, this.bucket, keys);
+  }
+  async copy(options, ctx = {}) {
+    const isFolder = options.fromPath.endsWith(this.delimiter);
+    const fromPath = normalizePath(options.fromPath);
+    const toPath = normalizePath(options.toPath);
+    if (fromPath === toPath) return;
+    if (isFolder) {
+      const fromPathWithSlash = ensureTrailingDelimiter(fromPath, this.delimiter);
+      const toPathWithSlash = ensureTrailingDelimiter(toPath, this.delimiter);
+      await this.authorize({
+        action: "folder.copy",
+        fromPath: fromPathWithSlash,
+        toPath: toPathWithSlash,
+        ctx
+      });
+      const fromPrefix = this.pathToFolderPrefix(fromPathWithSlash);
+      const toPrefix = this.pathToFolderPrefix(toPathWithSlash);
+      try {
+        await this.s3.send(
+          new CopyObjectCommand({
+            Bucket: this.bucket,
+            Key: toPrefix,
+            CopySource: encodeS3CopySource(this.bucket, fromPrefix)
+          })
+        );
+      } catch {
+      }
+      for await (const sourceKey of listAllKeys(this.s3, this.bucket, fromPrefix)) {
+        if (sourceKey === fromPrefix) continue;
+        const relKey = sourceKey.slice(fromPrefix.length);
+        const destKey = toPrefix + relKey;
+        try {
+          await this.s3.send(
+            new CopyObjectCommand({
+              Bucket: this.bucket,
+              Key: destKey,
+              CopySource: encodeS3CopySource(this.bucket, sourceKey)
+            })
+          );
+        } catch (err) {
+          if (isNoSuchKeyError(err)) continue;
+          throw err;
+        }
+      }
+      return;
+    }
+    await this.authorize({ action: "file.copy", fromPath, toPath, ctx });
+    const fromKey = this.pathToKey(fromPath);
+    const toKey = this.pathToKey(toPath);
+    await this.s3.send(
+      new CopyObjectCommand({
+        Bucket: this.bucket,
+        Key: toKey,
+        CopySource: encodeS3CopySource(this.bucket, fromKey)
+      })
+    );
+  }
+  async move(options, ctx = {}) {
+    const isFolder = options.fromPath.endsWith(this.delimiter);
+    const fromPath = normalizePath(options.fromPath);
+    const toPath = normalizePath(options.toPath);
+    if (fromPath === toPath) return;
+    if (isFolder) {
+      const fromPathWithSlash = ensureTrailingDelimiter(fromPath, this.delimiter);
+      const toPathWithSlash = ensureTrailingDelimiter(toPath, this.delimiter);
+      await this.authorize({
+        action: "folder.move",
+        fromPath: fromPathWithSlash,
+        toPath: toPathWithSlash,
+        ctx
+      });
+      await this.copy(options, ctx);
+      await this.deleteFolder({ path: fromPathWithSlash, recursive: true }, ctx);
+      return;
+    }
+    await this.authorize({ action: "file.move", fromPath, toPath, ctx });
+    await this.copy(options, ctx);
+    await this.deleteFiles({ paths: [fromPath] }, ctx);
+  }
+  async prepareUploads(options, ctx = {}) {
+    const expiresIn = options.expiresInSeconds ?? 60 * 5;
+    const result = [];
+    for (const item of options.items) {
+      const path = normalizePath(item.path);
+      await this.authorize({ action: "upload.prepare", path, ctx });
+      const key = this.pathToKey(path);
+      const cmd = new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+        ContentType: item.contentType,
+        CacheControl: item.cacheControl,
+        ContentDisposition: item.contentDisposition,
+        Metadata: item.metadata
+      });
+      const url = await getSignedUrl(this.s3, cmd, { expiresIn });
+      const headers = {};
+      if (item.contentType) headers["Content-Type"] = item.contentType;
+      if (item.cacheControl) headers["Cache-Control"] = item.cacheControl;
+      if (item.contentDisposition) headers["Content-Disposition"] = item.contentDisposition;
+      if (item.metadata) {
+        for (const [k, v] of Object.entries(item.metadata)) {
+          headers[`x-amz-meta-${k}`] = v;
+        }
+      }
+      result.push({
+        path,
+        url,
+        method: "PUT",
+        headers
+      });
+    }
+    return result;
+  }
+  async search(options, ctx = {}) {
+    const query = options.query.toLowerCase().trim();
+    if (!query) {
+      return { query: options.query, entries: [] };
+    }
+    await this.authorize({ action: "search", ctx });
+    const searchPrefix = options.path ? this.pathToFolderPrefix(normalizePath(options.path)) : this.rootPrefix;
+    const entries = [];
+    const limit = options.limit ?? 500;
+    const recursive = options.recursive !== false;
+    let cursor = options.cursor;
+    let nextCursor;
+    while (entries.length < limit) {
+      const out = await this.s3.send(
+        new ListObjectsV2Command({
+          Bucket: this.bucket,
+          Prefix: searchPrefix,
+          ContinuationToken: cursor,
+          MaxKeys: 1e3
+          // Fetch more to filter
+        })
+      );
+      nextCursor = out.IsTruncated && out.NextContinuationToken ? out.NextContinuationToken : void 0;
+      for (const obj of out.Contents ?? []) {
+        if (!obj.Key || obj.Key === searchPrefix) continue;
+        const path = this.keyToPath(obj.Key);
+        const name = path.split("/").at(-1) ?? "";
+        if (!recursive && options.path) {
+          const base = ensureTrailingDelimiter(normalizePath(options.path), this.delimiter);
+          const rel = path.startsWith(base) ? path.slice(base.length) : path;
+          if (rel.includes(this.delimiter)) continue;
+        }
+        if (!recursive && !options.path) {
+          if (path.includes(this.delimiter)) continue;
+        }
+        if (name.toLowerCase().includes(query)) {
+          const fileEntry = this.makeFileEntryFromKey(obj.Key, {
+            ...obj.Size !== void 0 ? { Size: obj.Size } : {},
+            ...obj.LastModified !== void 0 ? { LastModified: obj.LastModified } : {},
+            ...obj.ETag !== void 0 ? { ETag: obj.ETag } : {}
+          });
+          await this.hooks?.decorateFile?.(fileEntry, {
+            path: fileEntry.path,
+            key: this.pathToKey(fileEntry.path)
+          });
+          entries.push(fileEntry);
+        }
+        if (entries.length >= limit) break;
+      }
+      if (!out.IsTruncated || !out.NextContinuationToken) break;
+      cursor = out.NextContinuationToken;
+    }
+    return {
+      query: options.query,
+      entries,
+      ...nextCursor ? { nextCursor } : {}
+    };
+  }
+  async getPreviewUrl(options, ctx = {}) {
+    const path = normalizePath(options.path);
+    await this.authorize({ action: "preview.get", path, ctx });
+    const expiresIn = options.expiresInSeconds ?? 60 * 5;
+    const key = this.pathToKey(path);
+    const cmd = new GetObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+      ResponseContentDisposition: options.inline ? "inline" : "attachment"
+    });
+    const url = await getSignedUrl(this.s3, cmd, { expiresIn });
+    const expiresAt = new Date(Date.now() + expiresIn * 1e3).toISOString();
+    return { path, url, expiresAt };
+  }
+};
+
+// src/http/handler.ts
+var S3FileManagerHttpError = class extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+};
+function normalizeBasePath(basePath) {
+  if (!basePath) return "";
+  if (basePath === "/") return "";
+  return basePath.startsWith("/") ? basePath.replace(/\/+$/, "") : `/${basePath.replace(/\/+$/, "")}`;
+}
+function jsonError(status, code, message) {
+  return {
+    status,
+    headers: { "content-type": "application/json" },
+    body: {
+      error: {
+        code,
+        message
+      }
+    }
+  };
+}
+function ensureObject(body) {
+  if (body && typeof body === "object" && !Array.isArray(body))
+    return body;
+  throw new S3FileManagerHttpError(400, "invalid_body", "Expected JSON object body");
+}
+function optionalString(value, key) {
+  if (value === void 0) return void 0;
+  if (typeof value === "string") return value;
+  throw new S3FileManagerHttpError(400, "invalid_body", `Expected '${key}' to be a string`);
+}
+function requiredString(value, key) {
+  if (typeof value === "string") return value;
+  throw new S3FileManagerHttpError(400, "invalid_body", `Expected '${key}' to be a string`);
+}
+function optionalNumber(value, key) {
+  if (value === void 0) return void 0;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  throw new S3FileManagerHttpError(400, "invalid_body", `Expected '${key}' to be a finite number`);
+}
+function optionalBoolean(value, key) {
+  if (value === void 0) return void 0;
+  if (typeof value === "boolean") return value;
+  throw new S3FileManagerHttpError(400, "invalid_body", `Expected '${key}' to be a boolean`);
+}
+function requiredStringArray(value, key) {
+  if (!Array.isArray(value)) {
+    throw new S3FileManagerHttpError(
+      400,
+      "invalid_body",
+      `Expected '${key}' to be an array of strings`
+    );
+  }
+  for (const item of value) {
+    if (typeof item !== "string") {
+      throw new S3FileManagerHttpError(
+        400,
+        "invalid_body",
+        `Expected '${key}' to be an array of strings`
+      );
+    }
+  }
+  return value;
+}
+function optionalStringRecord(value, key) {
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new S3FileManagerHttpError(
+      400,
+      "invalid_body",
+      `Expected '${key}' to be an object of strings`
+    );
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (typeof v !== "string") {
+      throw new S3FileManagerHttpError(400, "invalid_body", `Expected '${key}.${k}' to be a string`);
+    }
+    out[k] = v;
+  }
+  return out;
+}
+function parseListOptions(body) {
+  const obj = ensureObject(body);
+  return {
+    path: requiredString(obj.path, "path"),
+    cursor: optionalString(obj.cursor, "cursor"),
+    limit: optionalNumber(obj.limit, "limit")
+  };
+}
+function parseSearchOptions(body) {
+  const obj = ensureObject(body);
+  return {
+    query: requiredString(obj.query, "query"),
+    path: optionalString(obj.path, "path"),
+    recursive: optionalBoolean(obj.recursive, "recursive"),
+    limit: optionalNumber(obj.limit, "limit"),
+    cursor: optionalString(obj.cursor, "cursor")
+  };
+}
+function parseCreateFolderOptions(body) {
+  const obj = ensureObject(body);
+  return { path: requiredString(obj.path, "path") };
+}
+function parseDeleteFolderOptions(body) {
+  const obj = ensureObject(body);
+  return {
+    path: requiredString(obj.path, "path"),
+    recursive: optionalBoolean(obj.recursive, "recursive")
+  };
+}
+function parseDeleteFilesOptions(body) {
+  const obj = ensureObject(body);
+  return { paths: requiredStringArray(obj.paths, "paths") };
+}
+function parseCopyMoveOptions(body) {
+  const obj = ensureObject(body);
+  return {
+    fromPath: requiredString(obj.fromPath, "fromPath"),
+    toPath: requiredString(obj.toPath, "toPath")
+  };
+}
+function parsePrepareUploadsOptions(body) {
+  const obj = ensureObject(body);
+  const itemsValue = obj.items;
+  if (!Array.isArray(itemsValue)) {
+    throw new S3FileManagerHttpError(400, "invalid_body", "Expected 'items' to be an array");
+  }
+  const items = itemsValue.map((raw, idx) => {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      throw new S3FileManagerHttpError(
+        400,
+        "invalid_body",
+        `Expected 'items[${idx}]' to be an object`
+      );
+    }
+    const item = raw;
+    return {
+      path: requiredString(item.path, `items[${idx}].path`),
+      contentType: optionalString(item.contentType, `items[${idx}].contentType`),
+      cacheControl: optionalString(item.cacheControl, `items[${idx}].cacheControl`),
+      contentDisposition: optionalString(
+        item.contentDisposition,
+        `items[${idx}].contentDisposition`
+      ),
+      metadata: optionalStringRecord(item.metadata, `items[${idx}].metadata`)
+    };
+  });
+  return {
+    items,
+    expiresInSeconds: optionalNumber(obj.expiresInSeconds, "expiresInSeconds")
+  };
+}
+function parsePreviewOptions(body) {
+  const obj = ensureObject(body);
+  return {
+    path: requiredString(obj.path, "path"),
+    expiresInSeconds: optionalNumber(obj.expiresInSeconds, "expiresInSeconds"),
+    inline: optionalBoolean(obj.inline, "inline")
+  };
+}
+function createS3FileManagerHttpHandler(options) {
+  const basePath = normalizeBasePath(options.api?.basePath);
+  if (!options.manager && !options.getManager) {
+    throw new Error("createS3FileManagerHttpHandler requires either manager or getManager");
+  }
+  return async (req) => {
+    try {
+      const ctx = await options.getContext?.(req) ?? {};
+      const manager = options.getManager ? await options.getManager(req, ctx) : options.manager;
+      const method = req.method.toUpperCase();
+      const path = req.path.startsWith(basePath) ? req.path.slice(basePath.length) || "/" : req.path;
+      if (method === "POST" && path === "/list") {
+        const out = await manager.list(parseListOptions(req.body), ctx);
+        return { status: 200, headers: { "content-type": "application/json" }, body: out };
+      }
+      if (method === "POST" && path === "/search") {
+        const out = await manager.search(parseSearchOptions(req.body), ctx);
+        return { status: 200, headers: { "content-type": "application/json" }, body: out };
+      }
+      if (method === "POST" && path === "/folder/create") {
+        await manager.createFolder(parseCreateFolderOptions(req.body), ctx);
+        return { status: 204 };
+      }
+      if (method === "POST" && path === "/folder/delete") {
+        await manager.deleteFolder(parseDeleteFolderOptions(req.body), ctx);
+        return { status: 204 };
+      }
+      if (method === "POST" && path === "/files/delete") {
+        await manager.deleteFiles(parseDeleteFilesOptions(req.body), ctx);
+        return { status: 204 };
+      }
+      if (method === "POST" && path === "/files/copy") {
+        await manager.copy(parseCopyMoveOptions(req.body), ctx);
+        return { status: 204 };
+      }
+      if (method === "POST" && path === "/files/move") {
+        await manager.move(parseCopyMoveOptions(req.body), ctx);
+        return { status: 204 };
+      }
+      if (method === "POST" && path === "/upload/prepare") {
+        const out = await manager.prepareUploads(parsePrepareUploadsOptions(req.body), ctx);
+        return { status: 200, headers: { "content-type": "application/json" }, body: out };
+      }
+      if (method === "POST" && path === "/preview") {
+        const out = await manager.getPreviewUrl(parsePreviewOptions(req.body), ctx);
+        return { status: 200, headers: { "content-type": "application/json" }, body: out };
+      }
+      return jsonError(404, "not_found", "Route not found");
+    } catch (err) {
+      if (err instanceof S3FileManagerHttpError) {
+        return jsonError(err.status, err.code, err.message);
+      }
+      if (err instanceof S3FileManagerAuthorizationError) {
+        return jsonError(err.status, err.code, err.message);
+      }
+      console.error("[S3FileManager Error]", err);
+      const message = err instanceof Error ? err.message : "Unknown error";
+      return jsonError(500, "internal_error", message);
+    }
+  };
+}
+
+// src/adapters/next.ts
+async function readJsonBody(req) {
+  const ct = req.headers.get("content-type") ?? "";
+  if (!ct.includes("application/json")) return void 0;
+  return await req.json();
+}
+function createNextRouteHandler(options) {
+  const handler = createS3FileManagerHttpHandler(options);
+  return async (req) => {
+    const url = new URL(req.url);
+    const body = await readJsonBody(req);
+    const httpReq = {
+      method: req.method,
+      path: url.pathname,
+      query: Object.fromEntries(url.searchParams.entries()),
+      headers: Object.fromEntries(req.headers.entries()),
+      body
+    };
+    const out = await handler(httpReq);
+    const init = { status: out.status };
+    if (out.headers) init.headers = out.headers;
+    return new Response(out.body ? JSON.stringify(out.body) : null, init);
+  };
+}
+var cachedEnvManager;
+var cachedEnvSignature;
+function requiredEnv(name) {
+  const v = process.env[name];
+  if (!v) throw new Error(`Missing env var: ${name}`);
+  return v;
+}
+function parseBool(v) {
+  if (!v) return false;
+  return v === "1" || v.toLowerCase() === "true";
+}
+function getEnvManager(options) {
+  const envMap = options.env;
+  const envSignature = JSON.stringify(envMap ?? {});
+  if (cachedEnvManager && cachedEnvSignature === envSignature) return cachedEnvManager;
+  const cfg = {
+    region: requiredEnv(envMap?.region ?? "AWS_REGION"),
+    bucket: requiredEnv(envMap?.bucket ?? "S3_BUCKET"),
+    rootPrefix: process.env[envMap?.rootPrefix ?? "S3_ROOT_PREFIX"] ?? "",
+    endpoint: process.env[envMap?.endpoint ?? "S3_ENDPOINT"],
+    forcePathStyle: parseBool(process.env[envMap?.forcePathStyle ?? "S3_FORCE_PATH_STYLE"]),
+    requireUserId: parseBool(process.env[envMap?.requireUserId ?? "REQUIRE_USER_ID"])
+  };
+  const s3 = new S3Client2({
+    region: cfg.region,
+    ...cfg.endpoint ? { endpoint: cfg.endpoint } : {},
+    ...cfg.forcePathStyle ? { forcePathStyle: true } : {}
+  });
+  const authorizeHook = cfg.requireUserId || options.authorization?.authorize ? async (args) => {
+    if (cfg.requireUserId && !args.ctx.userId) {
+      return false;
+    }
+    return options.authorization?.authorize?.(args);
+  } : void 0;
+  const allowActionHook = options.authorization?.allowAction;
+  const hooks = authorizeHook || allowActionHook ? {
+    ...authorizeHook ? { authorize: authorizeHook } : {},
+    ...allowActionHook ? { allowAction: allowActionHook } : {}
+  } : void 0;
+  cachedEnvManager = new S3FileManager(s3, {
+    bucket: cfg.bucket,
+    rootPrefix: cfg.rootPrefix,
+    ...options.authorization?.mode ? { authorizationMode: options.authorization.mode } : {},
+    ...hooks ? { hooks } : {}
+  });
+  cachedEnvSignature = envSignature;
+  return cachedEnvManager;
+}
+function getContextFromHeaders(headers, headerName) {
+  const raw = headers[headerName];
+  const userId = Array.isArray(raw) ? raw[0] : raw;
+  return userId ? { userId } : {};
+}
+function createNextRouteHandlerFromEnv(options = {}) {
+  const api = options.basePath ? { basePath: options.basePath } : void 0;
+  const handlerOptions = {
+    getManager: () => getEnvManager(options),
+    getContext: (req) => getContextFromHeaders(req.headers, options.userIdHeader ?? "x-user-id")
+  };
+  if (api) handlerOptions.api = api;
+  return createNextRouteHandler(handlerOptions);
+}
+function createNextApiHandler(options) {
+  const handler = createS3FileManagerHttpHandler(options);
+  return async (req, res) => {
+    const httpReq = {
+      method: req.method,
+      path: req.url?.split("?")[0] ?? "/",
+      query: req.query ?? {},
+      headers: req.headers ?? {},
+      body: req.body
+    };
+    const out = await handler(httpReq);
+    if (out.headers) {
+      for (const [k, v] of Object.entries(out.headers)) {
+        res.setHeader(k, v);
+      }
+    }
+    res.statusCode = out.status;
+    if (out.status === 204) {
+      res.end();
+      return;
+    }
+    res.setHeader("content-type", out.headers?.["content-type"] ?? "application/json");
+    res.end(JSON.stringify(out.body ?? null));
+  };
+}
+export {
+  createNextApiHandler,
+  createNextRouteHandler,
+  createNextRouteHandlerFromEnv
+};
+//# sourceMappingURL=next.js.map