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

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

@@ -1,457 +0,0 @@
-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 };