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

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 };