@visulima/storage 1.0.0-alpha.9 → 1.0.1

package/dist/packem_shared/Rest-DjwU3puo.js

@@ -1,267 +0,0 @@
-import { c as createHttpError } from './headers-YLRp1dLo.js';
-import { ERRORS } from './ERRORS-D0apMqnc.js';
-import { b as getRequestStream } from './base-handler-core-BoAqTyz7.js';
-import { B as BaseHandlerFetch } from './base-handler-fetch-D4u2xits.js';
-import { R as RestBase, c as parseContentDispositionValue } from './rest-base-D9URIFkc.js';
-
-class RestFetch extends BaseHandlerFetch {
-  /**
-   * Limiting enabled http method handler
-   */
-  static methods = ["delete", "download", "get", "head", "options", "patch", "post", "put"];
-  restBase;
-  constructor(options) {
-    super(options);
-    const restInstance = this;
-    this.restBase = new class extends RestBase {
-      // eslint-disable-next-line class-methods-use-this
-      get storage() {
-        return restInstance.storage;
-      }
-      // eslint-disable-next-line class-methods-use-this
-      buildFileUrl(requestUrl, file) {
-        return restInstance.buildFileUrl({ url: requestUrl }, file);
-      }
-    }();
-  }
-  /**
-   * Compose and register HTTP method handlers.
-   */
-  compose() {
-    this.registeredHandlers.set("POST", this.post.bind(this));
-    this.registeredHandlers.set("PUT", this.put.bind(this));
-    this.registeredHandlers.set("PATCH", this.patch.bind(this));
-    this.registeredHandlers.set("DELETE", this.delete.bind(this));
-    this.registeredHandlers.set("HEAD", this.head.bind(this));
-    this.registeredHandlers.set("GET", this.get.bind(this));
-    this.registeredHandlers.set("OPTIONS", this.options.bind(this));
-    this.logger?.debug("Registered handler: %s", [...this.registeredHandlers.keys()].join(", "));
-  }
-  /**
-   * Creates a new file via POST request with raw binary data.
-   * Supports both full file uploads and chunked upload initialization.
-   * @param request Web API Request with file data.
-   * @returns Promise resolving to ResponseFile with upload result.
-   */
-  async post(request) {
-    const isChunkedUpload = request.headers.get("x-chunked-upload") === "true";
-    const contentLengthHeader = request.headers.get("content-length");
-    const contentLength = contentLengthHeader ? Number.parseInt(contentLengthHeader, 10) : 0;
-    if (!isChunkedUpload) {
-      if (!contentLengthHeader || Number.isNaN(contentLength) || contentLength === 0) {
-        throw createHttpError(400, "Content-Length is required and must be greater than 0");
-      }
-      if (request.body === null) {
-        throw createHttpError(400, "Request body is required");
-      }
-    }
-    if (contentLength > this.storage.maxUploadSize) {
-      throw createHttpError(413, `File size exceeds maximum allowed size of ${this.storage.maxUploadSize} bytes`);
-    }
-    const contentType = request.headers.get("content-type") || "application/octet-stream";
-    const config = extractFileInitFromRequest(request, contentLength, contentType);
-    const requestUrl = request.url;
-    const bodyStream = request.body ? getRequestStream(request) : void 0;
-    return this.restBase.handlePost(config, isChunkedUpload, requestUrl, bodyStream, contentLength);
-  }
-  /**
-   * Create or update a file via PUT request.
-   * Requires file ID in the URL path.
-   * @param request Web API Request with file ID and data
-   * @returns Promise resolving to ResponseFile with upload result
-   */
-  async put(request) {
-    const id = getIdFromRequestUrl(request.url);
-    if (!id) {
-      throw createHttpError(400, "File ID is required in URL path");
-    }
-    if (request.body === null) {
-      throw createHttpError(400, "Request body is required");
-    }
-    const contentLengthHeader = request.headers.get("content-length");
-    const contentLength = contentLengthHeader ? Number.parseInt(contentLengthHeader, 10) : 0;
-    if (contentLength === 0) {
-      throw createHttpError(400, "Content-Length is required and must be greater than 0");
-    }
-    if (contentLength > this.storage.maxUploadSize) {
-      throw createHttpError(413, `File size exceeds maximum allowed size of ${this.storage.maxUploadSize} bytes`);
-    }
-    const contentType = request.headers.get("content-type") || "application/octet-stream";
-    const metadataHeader = request.headers.get("x-file-metadata");
-    let metadata;
-    if (metadataHeader) {
-      try {
-        metadata = JSON.parse(metadataHeader);
-      } catch {
-      }
-    }
-    const originalName = parseContentDispositionValue(request.headers.get("content-disposition"));
-    const config = {
-      contentType,
-      metadata: metadata || {},
-      originalName,
-      size: contentLength
-    };
-    const requestUrl = request.url;
-    const bodyStream = getRequestStream(request);
-    return this.restBase.handlePut(id, config, requestUrl, bodyStream, contentLength, metadata);
-  }
-  /**
-   * Delete an uploaded file or multiple files.
-   * Supports single file (ID in URL) or batch delete (via ?ids=id1,id2 or JSON body).
-   * @param request Web API Request with file ID(s)
-   * @returns Promise resolving to ResponseFile (single) or ResponseList (batch) with deletion result
-   */
-  async delete(request) {
-    const url = new URL(request.url);
-    const idsParameter = url.searchParams.get("ids");
-    if (idsParameter) {
-      const ids = idsParameter.split(",").map((id2) => id2.trim()).filter(Boolean);
-      if (ids.length === 0) {
-        throw createHttpError(400, "No file IDs provided");
-      }
-      return this.restBase.deleteBatch(ids);
-    }
-    const contentType = request.headers.get("content-type") || "";
-    if (contentType.includes("application/json")) {
-      try {
-        const body = await request.text();
-        const parsed = JSON.parse(body);
-        if (Array.isArray(parsed)) {
-          if (parsed.length === 0) {
-            throw createHttpError(400, "No file IDs provided");
-          }
-          return this.restBase.deleteBatch(parsed);
-        }
-        if (typeof parsed === "object" && parsed !== null && "ids" in parsed && Array.isArray(parsed.ids)) {
-          const idsArray = parsed.ids;
-          if (idsArray.length === 0) {
-            throw createHttpError(400, "No file IDs provided");
-          }
-          return this.restBase.deleteBatch(idsArray);
-        }
-      } catch (error) {
-        if (error.statusCode === 400) {
-          throw error;
-        }
-      }
-    }
-    const id = getIdFromRequestUrl(request.url);
-    if (!id) {
-      throw createHttpError(404, "File not found");
-    }
-    try {
-      return this.restBase.deleteSingle(id);
-    } catch (error) {
-      const errorWithCode = error;
-      if (errorWithCode.UploadErrorCode === ERRORS.FILE_NOT_FOUND || errorWithCode.code === "ENOENT") {
-        throw createHttpError(404, "File not found");
-      }
-      throw error;
-    }
-  }
-  /**
-   * Uploads a chunk via PATCH request for chunked uploads.
-   * Headers required: X-Chunk-Offset (byte offset), Content-Length (chunk size).
-   * Optional: X-Chunk-Checksum (SHA256 checksum for validation).
-   * @param request Web API Request with chunk data.
-   * @returns Promise resolving to ResponseFile with upload progress.
-   */
-  async patch(request) {
-    const id = getIdFromRequestUrl(request.url);
-    if (!id) {
-      throw createHttpError(404, "File not found");
-    }
-    if (request.body === null) {
-      throw createHttpError(400, "Request body is required");
-    }
-    const contentLengthHeader = request.headers.get("content-length");
-    const contentLength = contentLengthHeader ? Number.parseInt(contentLengthHeader, 10) : 0;
-    if (contentLength === 0) {
-      throw createHttpError(400, "Content-Length is required and must be greater than 0");
-    }
-    const chunkOffsetHeader = request.headers.get("x-chunk-offset");
-    const chunkOffset = chunkOffsetHeader ? Number.parseInt(chunkOffsetHeader, 10) : void 0;
-    if (chunkOffset === void 0) {
-      throw createHttpError(400, "X-Chunk-Offset header is required");
-    }
-    const chunkChecksum = request.headers.get("x-chunk-checksum") || void 0;
-    const requestUrl = request.url;
-    const bodyStream = getRequestStream(request);
-    return this.restBase.handlePatch(id, chunkOffset, contentLength, chunkChecksum, requestUrl, bodyStream);
-  }
-  /**
-   * Get file metadata via HEAD request.
-   * For chunked uploads, also returns upload progress information.
-   * @param request Web API Request with file ID
-   * @returns Promise resolving to ResponseFile with metadata headers
-   */
-  async head(request) {
-    const id = getIdFromRequestUrl(request.url);
-    if (!id) {
-      throw createHttpError(404, "File not found");
-    }
-    try {
-      return this.restBase.handleHead(id);
-    } catch (error) {
-      const errorWithCode = error;
-      if (errorWithCode.UploadErrorCode === ERRORS.FILE_NOT_FOUND || errorWithCode.code === "ENOENT") {
-        throw createHttpError(404, "File not found");
-      }
-      throw error;
-    }
-  }
-  /**
-   * Handle OPTIONS requests with REST API capabilities.
-   * @param _request Web API Request
-   * @returns Promise resolving to ResponseFile with CORS headers
-   */
-  async options(_request) {
-    return this.restBase.handleOptions(RestFetch.methods, this.storage.maxUploadSize);
-  }
-  /**
-   * Retrieves a file or list of files based on the request path.
-   * Delegates to BaseHandlerFetch.fetch() method.
-   * @param _request Web API Request
-   * @returns Promise resolving to Web API Response
-   */
-  // eslint-disable-next-line class-methods-use-this
-  async get(_request) {
-    throw createHttpError(500, "GET requests should be handled via fetch() method");
-  }
-}
-const extractFileInitFromRequest = (request, contentLength, contentType) => {
-  const totalSizeHeader = request.headers.get("x-total-size");
-  const totalSize = totalSizeHeader ? Number.parseInt(totalSizeHeader, 10) : contentLength;
-  const metadataHeader = request.headers.get("x-file-metadata");
-  let metadata = {};
-  if (metadataHeader) {
-    try {
-      metadata = JSON.parse(metadataHeader);
-    } catch {
-    }
-  }
-  const originalName = parseContentDispositionValue(request.headers.get("content-disposition"));
-  return {
-    contentType,
-    metadata,
-    originalName,
-    size: totalSize
-  };
-};
-const getIdFromRequestUrl = (url) => {
-  try {
-    const urlObject = new URL(url);
-    const pathParts = urlObject.pathname.split("/").filter(Boolean);
-    const lastPart = pathParts[pathParts.length - 1];
-    if (!lastPart) {
-      return null;
-    }
-    const id = lastPart.replace(/\.[^.]+$/, "");
-    return id || null;
-  } catch {
-    return null;
-  }
-};
-
-export { RestFetch as default };

package/dist/packem_shared/S3File-DZiyk9Qt.js

@@ -1,11 +0,0 @@
-import File from './File-Bb3P23dr.js';
-
-class S3File extends File {
-  Parts;
-  UploadId;
-  uri;
-  partsUrls;
-  partSize;
-}
-
-export { S3File as default };

package/dist/packem_shared/S3MetaStorage-Dz9aDabA.js

@@ -1,76 +0,0 @@
-import { S3Client, HeadObjectCommand, DeleteObjectCommand, PutObjectCommand, waitUntilBucketExists } from '@aws-sdk/client-s3';
-import { fromIni } from '@aws-sdk/credential-providers';
-import MetaStorage from './MetaStorage-pECeFOad.js';
-import { parseMetadata, stringifyMetadata } from './Metadata-DRLXeJ0F.js';
-import { i as isExpired } from './is-expired-CTThU1q5.js';
-
-class S3MetaStorage extends MetaStorage {
-  constructor(config) {
-    super(config);
-    this.config = config;
-    const { client, ...metaConfig } = config;
-    const bucket = metaConfig.bucket || process.env.S3_BUCKET;
-    if (client === void 0) {
-      if (!bucket) {
-        throw new Error("S3 bucket is not defined");
-      }
-      const keyFile = metaConfig.keyFile || process.env.S3_KEYFILE;
-      if (keyFile) {
-        metaConfig.credentials = fromIni({ configFilepath: keyFile });
-      }
-      this.client = new S3Client(metaConfig);
-      this.accessCheck(bucket).catch((error) => {
-        throw error;
-      });
-    } else {
-      this.client = client;
-    }
-    this.bucket = bucket;
-  }
-  bucket;
-  client;
-  async get(id) {
-    const Key = this.getMetaName(id);
-    const parameters = { Bucket: this.bucket, Key };
-    const { Expires, Metadata } = await this.client.send(new HeadObjectCommand(parameters));
-    if (Expires && isExpired({ expiredAt: Expires })) {
-      await this.delete(Key);
-      throw new Error(`Metafile ${id} not found`);
-    }
-    if (Metadata?.metadata !== void 0) {
-      const file = JSON.parse(decodeURIComponent(Metadata.metadata));
-      if (file.metadata && typeof file.metadata === "string") {
-        file.metadata = parseMetadata(file.metadata);
-      }
-      return file;
-    }
-    throw new Error(`Metafile ${id} not found`);
-  }
-  async touch(id, file) {
-    return this.save(id, file);
-  }
-  async delete(id) {
-    const parameters = { Bucket: this.bucket, Key: this.getMetaName(id) };
-    await this.client.send(new DeleteObjectCommand(parameters));
-  }
-  async save(id, file) {
-    const transformedMetadata = { ...file };
-    if (transformedMetadata.metadata) {
-      transformedMetadata.metadata = stringifyMetadata(file.metadata);
-    }
-    const metadata = encodeURIComponent(JSON.stringify(transformedMetadata));
-    const parameters = {
-      Bucket: this.bucket,
-      ContentLength: 0,
-      Key: this.getMetaName(id),
-      Metadata: { metadata }
-    };
-    await this.client.send(new PutObjectCommand(parameters));
-    return file;
-  }
-  async accessCheck(bucket, maxWaitTime = 30) {
-    await waitUntilBucketExists({ client: this.client, maxWaitTime }, { Bucket: bucket });
-  }
-}
-
-export { S3MetaStorage as default };

package/dist/packem_shared/S3Storage-DHmTk-hU.js

@@ -1,316 +0,0 @@
-import { Readable } from 'node:stream';
-import { CreateMultipartUploadCommand, UploadPartCommand, CompleteMultipartUploadCommand, AbortMultipartUploadCommand, ListPartsCommand, GetObjectCommand, HeadObjectCommand, DeleteObjectCommand, CopyObjectCommand, ListObjectsV2Command, waitUntilBucketExists, S3Client } from '@aws-sdk/client-s3';
-import { fromIni } from '@aws-sdk/credential-providers';
-import { S as S3BaseStorage } from './s3-base-storage-C1DIHTYY.js';
-import { ReadableStream } from 'node:stream/web';
-import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
-import S3File from './S3File-DZiyk9Qt.js';
-import S3MetaStorage from './S3MetaStorage-Dz9aDabA.js';
-
-class S3ClientAdapter {
-  constructor(client, _bucket) {
-    this.client = client;
-  }
-  async createMultipartUpload(params) {
-    const command = new CreateMultipartUploadCommand({
-      ACL: params.ACL,
-      Bucket: params.Bucket,
-      ContentType: params.ContentType,
-      Key: params.Key,
-      Metadata: params.Metadata
-    });
-    const response = await this.client.send(command);
-    if (!response.UploadId) {
-      throw new Error("Failed to create multipart upload");
-    }
-    return { UploadId: response.UploadId };
-  }
-  async uploadPart(params) {
-    const body = params.Body instanceof ReadableStream ? Readable.fromWeb(params.Body) : params.Body;
-    const command = new UploadPartCommand({
-      Body: body,
-      Bucket: params.Bucket,
-      ContentLength: params.ContentLength,
-      ContentMD5: params.ContentMD5,
-      Key: params.Key,
-      PartNumber: params.PartNumber,
-      UploadId: params.UploadId
-    });
-    const response = await this.client.send(command);
-    if (!response.ETag) {
-      throw new Error("Failed to upload part");
-    }
-    return { ETag: response.ETag };
-  }
-  async completeMultipartUpload(params) {
-    const command = new CompleteMultipartUploadCommand({
-      Bucket: params.Bucket,
-      Key: params.Key,
-      MultipartUpload: {
-        Parts: params.Parts.map(({ ETag, PartNumber }) => {
-          return { ETag, PartNumber };
-        })
-      },
-      UploadId: params.UploadId
-    });
-    const response = await this.client.send(command);
-    if (!response.Location) {
-      throw new Error("Failed to complete multipart upload");
-    }
-    return {
-      ETag: response.ETag,
-      Location: response.Location
-    };
-  }
-  async abortMultipartUpload(params) {
-    const command = new AbortMultipartUploadCommand({
-      Bucket: params.Bucket,
-      Key: params.Key,
-      UploadId: params.UploadId
-    });
-    await this.client.send(command);
-  }
-  async listParts(params) {
-    const command = new ListPartsCommand({
-      Bucket: params.Bucket,
-      Key: params.Key,
-      UploadId: params.UploadId
-    });
-    const response = await this.client.send(command);
-    const parts = [];
-    if (response.Parts) {
-      for (const part of response.Parts) {
-        if (part.ETag && part.PartNumber) {
-          parts.push({
-            ETag: part.ETag,
-            PartNumber: part.PartNumber,
-            Size: part.Size
-          });
-        }
-      }
-    }
-    return { Parts: parts.length > 0 ? parts : void 0 };
-  }
-  async getObject(params) {
-    const command = new GetObjectCommand({
-      Bucket: params.Bucket,
-      Key: params.Key
-    });
-    const response = await this.client.send(command);
-    let body;
-    if (response.Body) {
-      const sdkStream = response.Body;
-      if (sdkStream instanceof Readable) {
-        body = sdkStream;
-      } else if (typeof sdkStream === "object" && "transform" in sdkStream && sdkStream instanceof ReadableStream) {
-        body = sdkStream;
-      } else {
-        body = Readable.from(sdkStream);
-      }
-    }
-    return {
-      Body: body,
-      ContentLength: response.ContentLength,
-      ContentType: response.ContentType,
-      ETag: response.ETag,
-      Expires: response.Expires,
-      LastModified: response.LastModified,
-      Metadata: response.Metadata
-    };
-  }
-  async headObject(params) {
-    const command = new HeadObjectCommand({
-      Bucket: params.Bucket,
-      Key: params.Key
-    });
-    const response = await this.client.send(command);
-    return {
-      ContentLength: response.ContentLength,
-      ContentType: response.ContentType,
-      ETag: response.ETag,
-      Expires: response.Expires,
-      LastModified: response.LastModified
-    };
-  }
-  async deleteObject(params) {
-    const command = new DeleteObjectCommand({
-      Bucket: params.Bucket,
-      Key: params.Key
-    });
-    await this.client.send(command);
-  }
-  async copyObject(params) {
-    const commandInput = {
-      Bucket: params.Bucket,
-      CopySource: params.CopySource,
-      Key: params.Key
-    };
-    if (params.StorageClass) {
-      commandInput.StorageClass = params.StorageClass;
-    }
-    const command = new CopyObjectCommand(commandInput);
-    await this.client.send(command);
-  }
-  async listObjectsV2(params) {
-    const command = new ListObjectsV2Command({
-      Bucket: params.Bucket,
-      ContinuationToken: params.ContinuationToken,
-      MaxKeys: params.MaxKeys
-    });
-    const response = await this.client.send(command);
-    return {
-      Contents: response.Contents?.map((item) => {
-        return {
-          Key: item.Key,
-          LastModified: item.LastModified
-        };
-      }),
-      IsTruncated: response.IsTruncated,
-      NextContinuationToken: response.NextContinuationToken
-    };
-  }
-  async getPresignedUrl(params) {
-    const command = new UploadPartCommand({
-      Bucket: params.Bucket,
-      Key: params.Key,
-      PartNumber: params.PartNumber,
-      UploadId: params.UploadId
-    });
-    return getSignedUrl(this.client, command, { expiresIn: params.expiresIn });
-  }
-  async checkBucketAccess(params) {
-    await waitUntilBucketExists({ client: this.client, maxWaitTime: 30 }, { Bucket: params.Bucket });
-  }
-}
-
-class S3Storage extends S3BaseStorage {
-  static name = "s3";
-  s3Api;
-  constructor(config) {
-    const { bucket = process.env.S3_BUCKET, region = process.env.S3_REGION } = config;
-    if (!bucket) {
-      throw new Error("S3 bucket is not defined");
-    }
-    if (!region) {
-      throw new Error("S3 region is not defined");
-    }
-    config.region = region;
-    const keyFile = config.keyFile || process.env.S3_KEYFILE;
-    if (keyFile) {
-      config.credentials = fromIni({ configFilepath: keyFile });
-    }
-    const client = new S3Client(config);
-    super({
-      bucket,
-      clientDirectUpload: config.clientDirectUpload,
-      expiration: config.expiration?.maxAge ? { maxAge: String(config.expiration.maxAge) } : void 0,
-      filename: config.filename,
-      logger: config.logger,
-      metaStorage: config.metaStorage,
-      metaStorageConfig: config.metaStorageConfig ? { ...config.metaStorageConfig, ...config } : { ...config },
-      partSize: config.partSize,
-      retryConfig: {
-        ...config.retryConfig,
-        shouldRetry: (error) => {
-          const errorWithMetadata = error;
-          if (errorWithMetadata.$metadata) {
-            const statusCode = errorWithMetadata.$metadata.httpStatusCode;
-            if (statusCode && [408, 429, 500, 502, 503, 504].includes(statusCode)) {
-              return true;
-            }
-            if (errorWithMetadata.$fault === "server") {
-              return true;
-            }
-          }
-          return errorWithMetadata.retryable ?? false;
-        }
-      }
-    });
-    this.s3Api = new S3ClientAdapter(client, bucket);
-    const { metaStorage, metaStorageConfig } = config;
-    if (!metaStorage) {
-      const metaConfig = { ...config, ...metaStorageConfig, logger: this.logger };
-      const localMeta = "directory" in metaConfig;
-      if (!localMeta) {
-        this.meta = new S3MetaStorage(metaConfig);
-      }
-    }
-    if (this.config.clientDirectUpload) {
-      this.onCreate = async () => {
-      };
-    }
-  }
-  /**
-   * Normalizes AWS S3 errors with S3-specific context.
-   */
-  normalizeError(error) {
-    if (error.$metadata) {
-      return {
-        code: error.Code || error.name,
-        message: error.message,
-        name: error.name,
-        statusCode: error.$metadata.httpStatusCode || 500
-      };
-    }
-    return super.normalizeError(error);
-  }
-  async update({ id }, metadata) {
-    if (this.config.clientDirectUpload) {
-      const file = await this.getMeta(id);
-      return this.buildPresigned({ ...file, ...metadata });
-    }
-    return super.update({ id }, metadata);
-  }
-  async getStream({ id }) {
-    return this.instrumentOperation("getStream", async () => {
-      const s3Api = this.getS3Api();
-      const { Body, ContentLength, ContentType, ETag, Expires, LastModified } = await this.retry(
-        () => s3Api.getObject({
-          Bucket: this.bucket,
-          Key: id
-        })
-      );
-      await this.checkIfExpired({ expiredAt: Expires });
-      const stream = Body;
-      const readableStream = new Readable({
-        read() {
-          stream.on("data", (chunk) => {
-            this.push(chunk);
-          });
-          stream.on("end", () => {
-            this.push(null);
-          });
-          stream.on("error", (error) => {
-            this.destroy(error);
-          });
-        }
-      });
-      return {
-        headers: {
-          "Content-Length": ContentLength?.toString() ?? "0",
-          "Content-Type": ContentType,
-          ...ETag && { ETag },
-          ...Expires && { "X-Upload-Expires": Expires.toString() },
-          ...LastModified && { "Last-Modified": LastModified.toString() }
-        },
-        size: Number(ContentLength),
-        stream: readableStream
-      };
-    });
-  }
-  getS3Api() {
-    return this.s3Api;
-  }
-  // eslint-disable-next-line class-methods-use-this
-  getFileClass() {
-    return S3File;
-  }
-  getAcl() {
-    return this.config.acl;
-  }
-  async accessCheck(_maxWaitTime = 30) {
-    await this.s3Api.checkBucketAccess({ Bucket: this.bucket });
-  }
-}
-
-export { S3Storage as default };