@visulima/storage 1.0.0-alpha.1 → 1.0.0-alpha.3

package/dist/packem_shared/rest-base-GRCcnan7.js

@@ -0,0 +1,457 @@
+import { c as createHttpError } from './headers-DoS5nwM-.js';
+import { hasBody } from 'type-is';
+import { a as getHeader } from './base-handler-core-BKuf4YLT.js';
+import { ERRORS } from './ERRORS-D0apMqnc.js';
+import { b as buildResponseFile, a as buildFileHeaders, c as buildChunkedUploadHeaders, d as buildFileMetadataHeaders } from './response-builder-BtnRiBUI.js';
+
+const parseMetadata = (request, existingMetadata = {}) => {
+  const metadataHeader = getHeader(request, "x-file-metadata", true);
+  if (!metadataHeader) {
+    return existingMetadata;
+  }
+  try {
+    return { ...existingMetadata, ...JSON.parse(metadataHeader) };
+  } catch {
+    return existingMetadata;
+  }
+};
+const parseContentDispositionValue = (contentDisposition) => {
+  if (!contentDisposition) {
+    return void 0;
+  }
+  const maxSearchLength = 2e3;
+  const searchString = contentDisposition.length > maxSearchLength ? contentDisposition.slice(0, Math.max(0, maxSearchLength)) : contentDisposition;
+  const filenameIndex = searchString.toLowerCase().indexOf("filename");
+  if (filenameIndex === -1) {
+    return void 0;
+  }
+  let equalsIndex = filenameIndex + 8;
+  while (equalsIndex < searchString.length && (searchString[equalsIndex] === "*" || searchString[equalsIndex] === " " || searchString[equalsIndex] === "	")) {
+    equalsIndex++;
+  }
+  if (equalsIndex >= searchString.length || searchString[equalsIndex] !== "=") {
+    return void 0;
+  }
+  equalsIndex++;
+  while (equalsIndex < searchString.length && (searchString[equalsIndex] === " " || searchString[equalsIndex] === "	")) {
+    equalsIndex++;
+  }
+  if (equalsIndex >= searchString.length) {
+    return void 0;
+  }
+  let valueStart = equalsIndex;
+  let valueEnd;
+  const firstChar = searchString[equalsIndex];
+  if (firstChar === '"' || firstChar === "'") {
+    valueStart = equalsIndex + 1;
+    valueEnd = searchString.indexOf(firstChar, valueStart);
+    if (valueEnd === -1) {
+      valueEnd = searchString.indexOf(";", valueStart);
+      if (valueEnd === -1) {
+        valueEnd = searchString.length;
+      }
+    }
+  } else {
+    valueEnd = searchString.indexOf(";", valueStart);
+    if (valueEnd === -1) {
+      valueEnd = searchString.length;
+    }
+  }
+  if (valueStart >= valueEnd) {
+    return void 0;
+  }
+  const filename = searchString.substring(valueStart, valueEnd).trim();
+  return filename || void 0;
+};
+const parseContentDisposition = (request) => {
+  const contentDisposition = getHeader(request, "content-disposition", true);
+  return parseContentDispositionValue(contentDisposition);
+};
+const parseChunkHeaders = (request) => {
+  const isChunkedUpload = getHeader(request, "x-chunked-upload", true) === "true";
+  const chunkOffsetHeader = getHeader(request, "x-chunk-offset", true);
+  const totalSizeHeader = getHeader(request, "x-total-size", true);
+  const result = {
+    isChunkedUpload
+  };
+  if (chunkOffsetHeader) {
+    const offset = Number.parseInt(chunkOffsetHeader, 10);
+    if (!Number.isNaN(offset) && offset >= 0) {
+      result.chunkOffset = offset;
+    }
+  }
+  if (totalSizeHeader) {
+    const size = Number.parseInt(totalSizeHeader, 10);
+    if (!Number.isNaN(size) && size > 0) {
+      result.totalSize = size;
+    }
+  }
+  return result;
+};
+const validateRequestBody = (request, allowEmptyForChunked = false) => {
+  const isChunkedUpload = getHeader(request, "x-chunked-upload", true) === "true";
+  if (allowEmptyForChunked && isChunkedUpload) {
+    return;
+  }
+  if (!hasBody(request)) {
+    throw createHttpError(400, "Request body is required");
+  }
+  const contentLength = Number.parseInt(getHeader(request, "content-length") || "0", 10);
+  if (contentLength === 0 && !isChunkedUpload) {
+    throw createHttpError(400, "Content-Length is required and must be greater than 0");
+  }
+};
+const validateContentLength = (request, allowZeroForChunked = false, maxSize) => {
+  const isChunkedUpload = getHeader(request, "x-chunked-upload", true) === "true";
+  const contentLength = Number.parseInt(getHeader(request, "content-length") || "0", 10);
+  if (!allowZeroForChunked && !isChunkedUpload && contentLength === 0) {
+    throw createHttpError(400, "Content-Length is required and must be greater than 0");
+  }
+  if (maxSize !== void 0 && contentLength > maxSize) {
+    throw createHttpError(413, `File size exceeds maximum allowed size of ${maxSize} bytes`);
+  }
+  return contentLength;
+};
+const extractFileInit = (request, contentLength, contentType = "application/octet-stream") => {
+  const originalName = parseContentDisposition(request);
+  const metadata = parseMetadata(request);
+  const { isChunkedUpload, totalSize } = parseChunkHeaders(request);
+  const fileSize = isChunkedUpload && totalSize ? totalSize : contentLength;
+  if (isChunkedUpload && totalSize) {
+    metadata._chunkedUpload = true;
+    metadata._chunks = [];
+    metadata._totalSize = totalSize;
+  }
+  return {
+    contentType,
+    metadata,
+    originalName,
+    size: fileSize
+  };
+};
+
+const isUploadComplete = (chunks, totalSize) => {
+  if (chunks.length === 0) {
+    return false;
+  }
+  const sorted = [...chunks].toSorted((a, b) => a.offset - b.offset);
+  const firstChunk = sorted[0];
+  if (!firstChunk || firstChunk.offset !== 0) {
+    return false;
+  }
+  let currentEnd = firstChunk.length;
+  for (let i = 1; i < sorted.length; i += 1) {
+    const chunk = sorted[i];
+    if (!chunk) {
+      continue;
+    }
+    if (chunk.offset > currentEnd) {
+      return false;
+    }
+    currentEnd = Math.max(currentEnd, chunk.offset + chunk.length);
+  }
+  return currentEnd >= totalSize;
+};
+const validateChunk = (chunkOffset, chunkLength, totalSize, maxChunkSize) => {
+  if (Number.isNaN(chunkOffset) || chunkOffset < 0) {
+    throw new Error("Chunk offset must be a valid non-negative number");
+  }
+  if (chunkLength <= 0) {
+    throw new Error("Chunk length must be greater than 0");
+  }
+  if (chunkLength > maxChunkSize) {
+    throw new Error(`Chunk size exceeds maximum allowed size of ${maxChunkSize} bytes`);
+  }
+  if (chunkOffset + chunkLength > totalSize) {
+    throw new Error(`Chunk exceeds file size. Offset: ${chunkOffset}, Size: ${chunkLength}, Total: ${totalSize}`);
+  }
+};
+const trackChunk = (chunks, chunkInfo) => {
+  const existingChunk = chunks.find((chunk) => chunk.offset === chunkInfo.offset && chunk.length === chunkInfo.length);
+  if (!existingChunk) {
+    return [...chunks, chunkInfo];
+  }
+  if (chunkInfo.checksum && existingChunk.checksum !== chunkInfo.checksum) {
+    return chunks.map((chunk) => chunk.offset === chunkInfo.offset ? { ...chunk, checksum: chunkInfo.checksum } : chunk);
+  }
+  return chunks;
+};
+const isChunkedUpload = (file) => {
+  const metadata = file.metadata || {};
+  return metadata._chunkedUpload === true;
+};
+const getTotalSize = (file) => {
+  const metadata = file.metadata || {};
+  const isChunkedUploadFile = metadata._chunkedUpload === true;
+  if (isChunkedUploadFile && typeof metadata._totalSize === "number") {
+    return metadata._totalSize;
+  }
+  return void 0;
+};
+
+class RestBase {
+  /**
+   * Handle single file deletion.
+   * @param id File ID to delete
+   * @returns Promise resolving to ResponseFile with deletion result
+   */
+  async deleteSingle(id) {
+    const file = await this.storage.delete({ id });
+    if (file.status === void 0) {
+      throw createHttpError(404, "File not found");
+    }
+    return { ...file, headers: {}, statusCode: 204 };
+  }
+  /**
+   * Handle file creation (POST).
+   * @param config File initialization config
+   * @param isChunkedUpload Whether this is a chunked upload initialization
+   * @param requestUrl Request URL for Location header
+   * @param bodyStream Request body stream (for non-chunked uploads)
+   * @param contentLength Content length (for non-chunked uploads)
+   * @returns Promise resolving to ResponseFile with upload result
+   */
+  async handlePost(config, isChunkedUpload2, requestUrl, bodyStream, contentLength) {
+    if (isChunkedUpload2 && config.size !== void 0) {
+      const size = typeof config.size === "number" ? config.size : Number.parseInt(String(config.size), 10);
+      if (size > 0 && size > this.storage.maxUploadSize) {
+        throw createHttpError(413, `File size exceeds maximum allowed size of ${this.storage.maxUploadSize} bytes`);
+      }
+    }
+    const file = await this.storage.create(config);
+    if (isChunkedUpload2) {
+      const locationUrl2 = this.buildFileUrl(requestUrl, file);
+      return buildResponseFile(
+        file,
+        {
+          ...buildFileHeaders(file, locationUrl2),
+          "X-Chunked-Upload": "true",
+          "X-Upload-ID": file.id
+        },
+        201
+      );
+    }
+    const completedFile = await this.storage.write({
+      body: bodyStream,
+      contentLength,
+      id: file.id,
+      start: 0
+    });
+    const locationUrl = this.buildFileUrl(requestUrl, completedFile);
+    return buildResponseFile(completedFile, buildFileHeaders(completedFile, locationUrl), 201);
+  }
+  /**
+   * Handle file update or creation (PUT).
+   * @param id File ID from URL
+   * @param config File initialization config (for new files)
+   * @param requestUrl Request URL for Location header
+   * @param bodyStream Request body stream
+   * @param contentLength Content length
+   * @param metadata Optional metadata to merge (for updates)
+   * @returns Promise resolving to ResponseFile with upload result
+   */
+  async handlePut(id, config, requestUrl, bodyStream, contentLength, metadata) {
+    let file;
+    let isUpdate = false;
+    try {
+      await this.storage.getMeta(id);
+      isUpdate = true;
+      if (metadata) {
+        await this.storage.update({ id }, { metadata });
+      }
+      file = await this.storage.write({
+        body: bodyStream,
+        contentLength,
+        id,
+        start: 0
+      });
+    } catch (error) {
+      const errorWithCode = error;
+      if (errorWithCode.UploadErrorCode === ERRORS.FILE_NOT_FOUND || errorWithCode.code === "ENOENT") {
+        try {
+          const newFile = await this.storage.create(config);
+          file = await this.storage.write({
+            body: bodyStream,
+            contentLength,
+            id: newFile.id,
+            start: 0
+          });
+        } catch (createError) {
+          throw createError;
+        }
+      } else {
+        throw error;
+      }
+    }
+    const locationUrl = this.buildFileUrl(requestUrl, file);
+    return buildResponseFile(file, buildFileHeaders(file, locationUrl), isUpdate ? 200 : 201);
+  }
+  /**
+   * Handle chunked upload chunk (PATCH).
+   * @param id File ID from URL
+   * @param chunkOffset Chunk offset in bytes
+   * @param contentLength Chunk content length
+   * @param chunkChecksum Optional chunk checksum
+   * @param requestUrl Request URL for Location header
+   * @param bodyStream Request body stream
+   * @returns Promise resolving to ResponseFile with upload progress
+   */
+  async handlePatch(id, chunkOffset, contentLength, chunkChecksum, requestUrl, bodyStream) {
+    let file = await this.storage.getMeta(id);
+    const metadata = file.metadata || {};
+    const isChunkedUploadFile = isChunkedUpload(file);
+    if (isChunkedUploadFile) {
+      const totalSize2 = getTotalSize(file);
+      if (totalSize2 && file.size !== totalSize2) {
+        file = { ...file, size: totalSize2 };
+      }
+    }
+    const totalSize = typeof metadata._totalSize === "number" ? metadata._totalSize : file.size || 0;
+    if (!isChunkedUploadFile) {
+      throw createHttpError(400, "File is not a chunked upload. Use POST or PUT for full file uploads.");
+    }
+    const MAX_CHUNK_SIZE = 100 * 1024 * 1024;
+    try {
+      validateChunk(chunkOffset, contentLength, totalSize, MAX_CHUNK_SIZE);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("exceeds maximum")) {
+        throw createHttpError(413, error.message);
+      }
+      throw createHttpError(400, error instanceof Error ? error.message : String(error));
+    }
+    if (file.status === "completed") {
+      const locationUrl2 = this.buildFileUrl(requestUrl, file);
+      return buildResponseFile(
+        file,
+        {
+          ...buildFileHeaders(file, locationUrl2),
+          "X-Upload-Complete": "true"
+        },
+        200
+      );
+    }
+    const existingChunks = Array.isArray(metadata._chunks) ? metadata._chunks : [];
+    const chunkInfo = {
+      checksum: chunkChecksum,
+      length: contentLength,
+      offset: chunkOffset
+    };
+    const chunks = trackChunk(existingChunks, chunkInfo);
+    const updatedMetadata = {
+      ...metadata,
+      _chunks: chunks
+    };
+    await this.storage.update({ id }, { metadata: updatedMetadata });
+    let updatedFile = await this.storage.write({
+      body: bodyStream,
+      contentLength,
+      id,
+      start: chunkOffset
+    });
+    let isComplete = updatedFile.bytesWritten >= totalSize;
+    if (isChunkedUploadFile) {
+      const isChunksComplete = isUploadComplete(chunks, totalSize);
+      isComplete = isChunksComplete;
+      if (updatedFile.status === "completed" && !isComplete) {
+        await this.storage.update({ id }, { status: "part" });
+        updatedFile = { ...updatedFile, status: "part" };
+      }
+    }
+    const finalFile = isComplete && updatedFile.bytesWritten !== totalSize ? { ...updatedFile, bytesWritten: totalSize } : updatedFile;
+    const locationUrl = this.buildFileUrl(requestUrl, finalFile);
+    const headers = {
+      ...buildFileHeaders(finalFile, locationUrl),
+      ...buildChunkedUploadHeaders(finalFile, isComplete),
+      "x-upload-offset": String(finalFile.bytesWritten || 0)
+    };
+    return buildResponseFile(finalFile, headers, isComplete ? 200 : 202);
+  }
+  /**
+   * Handle file metadata retrieval (HEAD).
+   * @param id File ID from URL
+   * @returns Promise resolving to ResponseFile with metadata headers
+   */
+  async handleHead(id) {
+    let file = await this.storage.getMeta(id);
+    const isChunkedUploadFile = isChunkedUpload(file);
+    if (isChunkedUploadFile) {
+      const totalSize = getTotalSize(file);
+      if (totalSize && file.size !== totalSize) {
+        file = { ...file, size: totalSize };
+      }
+    }
+    const headers = {
+      ...buildFileMetadataHeaders(file)
+    };
+    if (isChunkedUploadFile) {
+      const metadata = file.metadata || {};
+      const totalSize = getTotalSize(file) || file.size || 0;
+      const chunks = Array.isArray(metadata._chunks) ? metadata._chunks : [];
+      const isComplete = isUploadComplete(chunks, totalSize);
+      Object.assign(headers, buildChunkedUploadHeaders(file, isComplete));
+    }
+    return buildResponseFile(file, headers, 200);
+  }
+  /**
+   * Handle OPTIONS request with REST API capabilities.
+   * @param methods Array of supported HTTP methods
+   * @param maxUploadSize Maximum upload size
+   * @returns ResponseFile with CORS headers
+   */
+  // eslint-disable-next-line class-methods-use-this
+  handleOptions(methods, maxUploadSize) {
+    const headers = {
+      "Access-Control-Allow-Headers": "Authorization, Content-Type, Content-Length, Content-Disposition, X-File-Metadata, X-Chunked-Upload, X-Total-Size, X-Chunk-Offset, X-Chunk-Checksum",
+      "Access-Control-Allow-Methods": methods.map((method) => method.toUpperCase()).join(", "),
+      "Access-Control-Max-Age": 86400,
+      "X-Max-Upload-Size": String(maxUploadSize)
+    };
+    return {
+      headers,
+      statusCode: 204
+    };
+  }
+  /**
+   * Handle batch file deletion.
+   * @param ids Array of file IDs to delete
+   * @returns Promise resolving to ResponseList with deletion results
+   */
+  async deleteBatch(ids) {
+    const result = await this.storage.deleteBatch(ids);
+    if (result.successfulCount === 0 && result.failedCount > 0) {
+      const failedIds = result.failed.map((errorItem) => errorItem.id).join(", ");
+      throw createHttpError(404, `Failed to delete files: ${failedIds}`);
+    }
+    return {
+      data: result.successful,
+      headers: result.failedCount > 0 ? {
+        "X-Delete-Errors": JSON.stringify(result.failed),
+        "X-Delete-Failed": String(result.failedCount),
+        "X-Delete-Successful": String(result.successfulCount)
+      } : {
+        "X-Delete-Successful": String(result.successfulCount)
+      },
+      statusCode: result.successfulCount === ids.length ? 204 : 207
+      // 207 Multi-Status for partial success
+    };
+  }
+  /**
+   * Storage instance for file operations.
+   */
+  // eslint-disable-next-line class-methods-use-this
+  get storage() {
+    throw new Error("storage must be implemented");
+  }
+  /**
+   * Build file URL from request URL and file data.
+   * @param _requestUrl Request URL string
+   * @param _file File object containing ID and content type
+   * @returns Constructed file URL with extension based on content type
+   */
+  // eslint-disable-next-line class-methods-use-this
+  buildFileUrl(_requestUrl, _file) {
+    throw new Error("buildFileUrl must be implemented");
+  }
+}
+
+export { RestBase as R, validateContentLength as a, parseChunkHeaders as b, parseContentDispositionValue as c, extractFileInit as e, parseContentDisposition as p, validateRequestBody as v };