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

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

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