nextly 0.0.1 → 0.0.2-alpha.0

package/dist/api/uploads.mjs

@@ -0,0 +1,359 @@
+import {
+  withErrorHandler
+} from "../chunk-TO5AFLVQ.mjs";
+import {
+  getCachedNextly
+} from "../chunk-P7NH2OSC.mjs";
+import "../chunk-2OALJTK6.mjs";
+import "../chunk-VJ66NCL4.mjs";
+import "../chunk-R6JJQHFC.mjs";
+import "../chunk-X23WKS3Z.mjs";
+import {
+  getService,
+  isServicesRegistered
+} from "../chunk-X7TXCYYN.mjs";
+import "../chunk-YZNBLFIW.mjs";
+import "../chunk-FQULBZ53.mjs";
+import "../chunk-67GXH6PR.mjs";
+import "../chunk-2TFX4ND3.mjs";
+import "../chunk-W4MGXIRR.mjs";
+import {
+  UploadService,
+  clampLimit2 as clampLimit
+} from "../chunk-NSEFNNU4.mjs";
+import "../chunk-3FA7FKAV.mjs";
+import "../chunk-AGJ6F2T3.mjs";
+import "../chunk-KIMNCZGV.mjs";
+import "../chunk-AK6Z23OX.mjs";
+import "../chunk-INV7QKLG.mjs";
+import "../chunk-GZ6DCQKC.mjs";
+import "../chunk-SBACDPNX.mjs";
+import "../chunk-RJLLGGPG.mjs";
+import "../chunk-V4EQTOA4.mjs";
+import "../chunk-I4JMR3UR.mjs";
+import "../chunk-XZKLBMN6.mjs";
+import "../chunk-IZWPRDC3.mjs";
+import "../chunk-DNNG377Z.mjs";
+import "../chunk-5HMZ644B.mjs";
+import "../chunk-W5KKPZT5.mjs";
+import "../chunk-56WO4WX7.mjs";
+import {
+  withTimezoneFormatting
+} from "../chunk-2W3DVD7S.mjs";
+import "../chunk-TS7GHTG2.mjs";
+import "../chunk-H26B4FYG.mjs";
+import "../chunk-DP3G27G5.mjs";
+import "../chunk-DV6WVX2Q.mjs";
+import "../chunk-UJ2IMJ4W.mjs";
+import {
+  getMediaStorage
+} from "../chunk-EGXBZCGC.mjs";
+import "../chunk-G2AA4QLC.mjs";
+import "../chunk-4MJLT6PZ.mjs";
+import {
+  respondAction,
+  respondDoc,
+  respondList,
+  respondMutation
+} from "../chunk-IUDOC7N7.mjs";
+import "../chunk-LAZXX4HR.mjs";
+import {
+  container
+} from "../chunk-D5HQBNUB.mjs";
+import {
+  NextlyError
+} from "../chunk-NRUWQ5Z7.mjs";
+import "../chunk-VTJADRO3.mjs";
+import "../chunk-5APFUGAD.mjs";
+import "../chunk-7P6ASYW6.mjs";
+
+// src/utils/parse-byte-size.ts
+var UNITS = {
+  b: 1,
+  kb: 1024,
+  mb: 1024 * 1024,
+  gb: 1024 * 1024 * 1024,
+  tb: 1024 * 1024 * 1024 * 1024
+};
+function parseByteSize(value) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value <= 0 || !Number.isInteger(value)) {
+      throw new Error(
+        `[nextly/security/limits] expected positive integer byte count; got ${value}`
+      );
+    }
+    return value;
+  }
+  const trimmed = value.trim().toLowerCase();
+  const match = trimmed.match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb|tb)?$/);
+  if (!match) {
+    throw new Error(
+      `[nextly/security/limits] cannot parse byte size: "${value}". Use a number or "1mb" / "500kb" etc.`
+    );
+  }
+  const n = Number(match[1]);
+  const unit = match[2] ?? "b";
+  return Math.floor(n * UNITS[unit]);
+}
+var DEFAULT_SECURITY_LIMITS = {
+  json: parseByteSize("1mb"),
+  multipart: parseByteSize("50mb"),
+  fileSize: parseByteSize("10mb"),
+  fileCount: 10,
+  fieldCount: 50,
+  fieldSize: parseByteSize("100kb")
+};
+function resolveSecurityLimits(raw) {
+  if (!raw) return DEFAULT_SECURITY_LIMITS;
+  return {
+    json: raw.json !== void 0 ? parseByteSize(raw.json) : DEFAULT_SECURITY_LIMITS.json,
+    multipart: raw.multipart !== void 0 ? parseByteSize(raw.multipart) : DEFAULT_SECURITY_LIMITS.multipart,
+    fileSize: raw.fileSize !== void 0 ? parseByteSize(raw.fileSize) : DEFAULT_SECURITY_LIMITS.fileSize,
+    fileCount: raw.fileCount ?? DEFAULT_SECURITY_LIMITS.fileCount,
+    fieldCount: raw.fieldCount ?? DEFAULT_SECURITY_LIMITS.fieldCount,
+    fieldSize: raw.fieldSize !== void 0 ? parseByteSize(raw.fieldSize) : DEFAULT_SECURITY_LIMITS.fieldSize
+  };
+}
+function checkRequestSize(request, limit) {
+  const lengthHeader = request.headers.get("content-length");
+  if (!lengthHeader) return null;
+  const length = Number(lengthHeader);
+  if (!Number.isFinite(length) || length < 0) return null;
+  if (length > limit) {
+    return new Response(
+      JSON.stringify({
+        error: {
+          code: "PAYLOAD_TOO_LARGE",
+          message: `Request body exceeds the configured limit of ${limit} bytes.`
+        }
+      }),
+      {
+        status: 413,
+        headers: { "content-type": "application/json" }
+      }
+    );
+  }
+  return null;
+}
+
+// src/api/uploads.ts
+function resolveSecurityLimitsFromContainer() {
+  try {
+    if (!container.has("config")) return resolveSecurityLimits(void 0);
+    const cfg = container.get("config");
+    return resolveSecurityLimits(cfg?.security?.limits);
+  } catch {
+    return resolveSecurityLimits(void 0);
+  }
+}
+function getUploadService(_collectionSlug, config) {
+  const storage = getMediaStorage().getAdapter();
+  let uploadSecurityConfig;
+  if (isServicesRegistered()) {
+    const serviceConfig = getService("config");
+    uploadSecurityConfig = serviceConfig.security?.uploads;
+  }
+  return new UploadService(storage, {
+    maxSize: config?.maxSize,
+    allowedMimeTypes: config?.allowedMimeTypes ?? uploadSecurityConfig?.allowedMimeTypes,
+    additionalMimeTypes: config?.additionalMimeTypes ?? uploadSecurityConfig?.additionalMimeTypes,
+    svgCsp: uploadSecurityConfig?.svgCsp,
+    generateThumbnails: config?.generateThumbnails,
+    thumbnailSize: config?.thumbnailSize
+  });
+}
+function resetUploadService() {
+}
+async function ensureServicesInitialized() {
+  await getCachedNextly();
+}
+async function extractParams(params) {
+  const resolved = await params;
+  return {
+    slug: resolved.slug || "",
+    id: resolved.id
+  };
+}
+function requireSlug(slug) {
+  if (!slug) {
+    throw NextlyError.validation({
+      errors: [
+        {
+          path: "slug",
+          code: "REQUIRED",
+          message: "Collection slug is required."
+        }
+      ],
+      logContext: { reason: "missing-collection-slug" }
+    });
+  }
+}
+function throwFromUploadResult(result, operation) {
+  const logContext = {
+    operation,
+    legacyStatus: result.statusCode,
+    legacyMessage: result.message
+  };
+  if (result.statusCode === 404) {
+    throw NextlyError.notFound({ logContext });
+  }
+  if (result.statusCode === 400) {
+    const errors = result.errors && result.errors.length > 0 ? result.errors.map((e) => ({
+      path: e.field ?? "",
+      code: "INVALID_INPUT",
+      message: e.message
+    })) : [
+      {
+        path: "",
+        code: "INVALID_INPUT",
+        message: result.message ?? "Invalid input."
+      }
+    ];
+    throw NextlyError.validation({ errors, logContext });
+  }
+  if (result.statusCode === 503) {
+    throw NextlyError.serviceUnavailable({ logContext });
+  }
+  throw NextlyError.internal({ logContext });
+}
+var POST = withErrorHandler(
+  async (request, context) => {
+    await ensureServicesInitialized();
+    const { slug } = await extractParams(context.params);
+    requireSlug(slug);
+    const limits = resolveSecurityLimitsFromContainer();
+    const tooLarge = checkRequestSize(request, limits.multipart);
+    if (tooLarge) return tooLarge;
+    const formData = await request.formData();
+    const file = formData.get("file");
+    if (!file) {
+      throw NextlyError.validation({
+        errors: [
+          { path: "file", code: "REQUIRED", message: "file is required." }
+        ],
+        logContext: { reason: "missing-file" }
+      });
+    }
+    if (file.size > limits.fileSize) {
+      return new Response(
+        JSON.stringify({
+          error: {
+            code: "PAYLOAD_TOO_LARGE",
+            message: `File "${file.name}" (${file.size} bytes) exceeds the configured per-file limit of ${limits.fileSize} bytes.`
+          }
+        }),
+        { status: 413, headers: { "content-type": "application/json" } }
+      );
+    }
+    const payloadStr = formData.get("_payload");
+    let additionalData = {};
+    if (payloadStr) {
+      try {
+        additionalData = JSON.parse(payloadStr);
+      } catch {
+      }
+    }
+    const arrayBuffer = await file.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    const uploadService = getUploadService(slug);
+    const result = await uploadService.upload(buffer, {
+      filename: file.name,
+      mimeType: file.type || "application/octet-stream",
+      collectionSlug: slug
+    });
+    if (!result.success) {
+      throwFromUploadResult(result, "upload");
+    }
+    const uploadData = {
+      id: result.data?.id,
+      filename: result.data?.filename,
+      mimeType: result.data?.mimeType,
+      filesize: result.data?.size,
+      url: result.data?.url,
+      thumbnailUrl: result.data?.thumbnailUrl,
+      width: result.data?.width,
+      height: result.data?.height,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...additionalData
+    };
+    return withTimezoneFormatting(
+      respondMutation("Upload created.", uploadData, { status: 201 })
+    );
+  }
+);
+var GET = withErrorHandler(
+  async (request, context) => {
+    await ensureServicesInitialized();
+    const { slug, id } = await extractParams(context.params);
+    requireSlug(slug);
+    if (!id) {
+      return handleList(request, slug);
+    }
+    const uploadService = getUploadService(slug);
+    const filePath = `${slug}/${id}`;
+    const result = await uploadService.getMetadata(filePath);
+    if (!result.success) {
+      throwFromUploadResult(result, "get-metadata");
+    }
+    const uploadData = {
+      id: result.data?.id,
+      filename: result.data?.filename || result.data?.originalFilename,
+      mimeType: result.data?.mimeType,
+      filesize: result.data?.size,
+      url: result.data?.url,
+      thumbnailUrl: result.data?.thumbnailUrl,
+      width: result.data?.width,
+      height: result.data?.height,
+      createdAt: result.data?.createdAt,
+      updatedAt: result.data?.updatedAt
+    };
+    return withTimezoneFormatting(respondDoc(uploadData));
+  }
+);
+async function handleList(request, _slug) {
+  const { searchParams } = new URL(request.url);
+  const page = parseInt(searchParams.get("page") || "1", 10);
+  const limit = clampLimit(searchParams.get("limit"), { defaultLimit: 10 });
+  const total = 0;
+  const totalPages = limit > 0 ? Math.ceil(total / limit) : 0;
+  return withTimezoneFormatting(
+    respondList([], {
+      total,
+      page,
+      limit,
+      totalPages,
+      hasNext: page < totalPages,
+      hasPrev: page > 1
+    })
+  );
+}
+var DELETE = withErrorHandler(
+  async (_request, context) => {
+    await ensureServicesInitialized();
+    const { slug, id } = await extractParams(context.params);
+    requireSlug(slug);
+    if (!id) {
+      throw NextlyError.validation({
+        errors: [
+          { path: "id", code: "REQUIRED", message: "Upload ID is required." }
+        ],
+        logContext: { reason: "missing-upload-id" }
+      });
+    }
+    const uploadService = getUploadService(slug);
+    const filePath = `${slug}/${id}`;
+    const result = await uploadService.delete(filePath);
+    if (!result.success) {
+      throwFromUploadResult(result, "delete");
+    }
+    return respondAction("Upload deleted.", { id });
+  }
+);
+var LIST = GET;
+export {
+  DELETE,
+  GET,
+  LIST,
+  POST,
+  resetUploadService
+};