@fluxmedia/s3 0.1.0-alpha.0 → 0.1.1

package/dist/index.cjs

@@ -1,195 +1,366 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
+'use strict';
+
+var core = require('@fluxmedia/core');
 
-//#endregion
-const __fluxmedia_core = __toESM(require("@fluxmedia/core"));
+// src/s3-provider.ts
 
-//#region src/features.ts
-/**
-* Feature matrix for S3 provider.
-* S3 is storage-only - no transformation support.
-*/
-const S3Features = {
-	transformations: {
-		resize: false,
-		crop: false,
-		format: false,
-		quality: false,
-		blur: false,
-		rotate: false,
-		effects: false
-	},
-	capabilities: {
-		signedUploads: true,
-		directUpload: true,
-		multipartUpload: true,
-		videoProcessing: false,
-		aiTagging: false,
-		facialDetection: false
-	},
-	storage: {
-		maxFileSize: 5 * 1024 * 1024 * 1024,
-		supportedFormats: ["*"]
-	}
+// src/features.ts
+var S3Features = {
+  transformations: {
+    resize: false,
+    crop: false,
+    format: false,
+    quality: false,
+    blur: false,
+    rotate: false,
+    effects: false
+  },
+  capabilities: {
+    signedUploads: true,
+    directUpload: true,
+    multipartUpload: true,
+    videoProcessing: false,
+    aiTagging: false,
+    facialDetection: false
+  },
+  storage: {
+    maxFileSize: 5 * 1024 * 1024 * 1024,
+    // 5GB
+    supportedFormats: ["*"]
+    // All formats
+  }
 };
 
-//#endregion
-//#region src/s3-provider.ts
-/**
-* AWS S3 provider implementation.
-* Storage-focused provider without transformation support.
-*/
+// src/s3-provider.ts
+var cachedS3Client = null;
+var cachedDeleteObjectCommand = null;
+var cachedHeadObjectCommand = null;
+var cachedUpload = null;
+async function getS3Imports() {
+  if (!cachedS3Client) {
+    const sdk = await import('@aws-sdk/client-s3');
+    cachedS3Client = sdk.S3Client;
+    cachedDeleteObjectCommand = sdk.DeleteObjectCommand;
+    cachedHeadObjectCommand = sdk.HeadObjectCommand;
+  }
+  return {
+    S3Client: cachedS3Client,
+    DeleteObjectCommand: cachedDeleteObjectCommand,
+    HeadObjectCommand: cachedHeadObjectCommand
+  };
+}
+async function getUploadClass() {
+  if (!cachedUpload) {
+    const libStorage = await import('@aws-sdk/lib-storage');
+    cachedUpload = libStorage.Upload;
+  }
+  return cachedUpload;
+}
 var S3Provider = class {
-	name = "s3";
-	features = S3Features;
-	client = null;
-	config;
-	constructor(config) {
-		this.config = config;
-	}
-	/**
-	* Lazy-loads the AWS S3 SDK to minimize bundle size.
-	*/
-	async ensureClient() {
-		if (!this.client) {
-			const { S3Client } = await import("@aws-sdk/client-s3");
-			this.client = new S3Client({
-				region: this.config.region,
-				credentials: {
-					accessKeyId: this.config.accessKeyId,
-					secretAccessKey: this.config.secretAccessKey
-				},
-				endpoint: this.config.endpoint,
-				forcePathStyle: this.config.forcePathStyle
-			});
-		}
-		return this.client;
-	}
-	async upload(file, options) {
-		const client = await this.ensureClient();
-		try {
-			const { PutObjectCommand } = await import("@aws-sdk/client-s3");
-			const key = this.generateKey(options);
-			const body = file instanceof Buffer ? file : await this.fileToBuffer(file);
-			if (options?.onProgress) options.onProgress(0);
-			const command = new PutObjectCommand({
-				Bucket: this.config.bucket,
-				Key: key,
-				Body: body,
-				ContentType: this.getContentType(file)
-			});
-			await client.send(command);
-			if (options?.onProgress) options.onProgress(100);
-			return this.createResult(key, body.length);
-		} catch (error) {
-			throw (0, __fluxmedia_core.createMediaError)(__fluxmedia_core.MediaErrorCode.UPLOAD_FAILED, this.name, error);
-		}
-	}
-	async delete(id) {
-		const client = await this.ensureClient();
-		try {
-			const { DeleteObjectCommand } = await import("@aws-sdk/client-s3");
-			const command = new DeleteObjectCommand({
-				Bucket: this.config.bucket,
-				Key: id
-			});
-			await client.send(command);
-		} catch (error) {
-			throw (0, __fluxmedia_core.createMediaError)(__fluxmedia_core.MediaErrorCode.DELETE_FAILED, this.name, error);
-		}
-	}
-	async get(id) {
-		const client = await this.ensureClient();
-		try {
-			const { HeadObjectCommand } = await import("@aws-sdk/client-s3");
-			const command = new HeadObjectCommand({
-				Bucket: this.config.bucket,
-				Key: id
-			});
-			const response = await client.send(command);
-			return {
-				id,
-				url: this.getUrl(id),
-				publicUrl: this.getUrl(id),
-				size: response.ContentLength ?? 0,
-				format: this.extractFormat(id),
-				provider: this.name,
-				metadata: { contentType: response.ContentType },
-				createdAt: response.LastModified ?? /* @__PURE__ */ new Date()
-			};
-		} catch (error) {
-			throw (0, __fluxmedia_core.createMediaError)(__fluxmedia_core.MediaErrorCode.FILE_NOT_FOUND, this.name, error);
-		}
-	}
-	getUrl(id, _transform) {
-		if (this.config.endpoint) return `${this.config.endpoint}/${this.config.bucket}/${id}`;
-		return `https://${this.config.bucket}.s3.${this.config.region}.amazonaws.com/${id}`;
-	}
-	async uploadMultiple(files, options) {
-		const uploadPromises = files.map((file) => this.upload(file, options));
-		return Promise.all(uploadPromises);
-	}
-	async deleteMultiple(ids) {
-		const deletePromises = ids.map((id) => this.delete(id));
-		await Promise.all(deletePromises);
-	}
-	get native() {
-		return this.client;
-	}
-	generateKey(options) {
-		const filename = options?.filename ?? this.generateRandomId();
-		const folder = options?.folder ? `${options.folder}/` : "";
-		return `${folder}${filename}`;
-	}
-	generateRandomId() {
-		return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
-	}
-	getContentType(file) {
-		if (file instanceof Buffer) return "application/octet-stream";
-		return file.type || "application/octet-stream";
-	}
-	extractFormat(key) {
-		const parts = key.split(".");
-		return parts.length > 1 ? parts[parts.length - 1] ?? "" : "";
-	}
-	async fileToBuffer(file) {
-		const arrayBuffer = await file.arrayBuffer();
-		return Buffer.from(arrayBuffer);
-	}
-	createResult(key, size) {
-		return {
-			id: key,
-			url: this.getUrl(key),
-			publicUrl: this.getUrl(key),
-			size,
-			format: this.extractFormat(key),
-			provider: this.name,
-			metadata: {},
-			createdAt: /* @__PURE__ */ new Date()
-		};
-	}
+  constructor(config) {
+    this.name = "s3";
+    this.features = S3Features;
+    this.client = null;
+    this.clientPromise = null;
+    const required = ["region", "bucket", "accessKeyId", "secretAccessKey"];
+    const missing = required.filter((field) => !config[field]);
+    if (missing.length > 0) {
+      throw core.createMediaError(
+        core.MediaErrorCode.INVALID_CONFIG,
+        "s3",
+        new Error(`Missing required S3 configuration: ${missing.join(", ")}`)
+      );
+    }
+    if (config.bucket.includes("/")) {
+      throw core.createMediaError(
+        core.MediaErrorCode.INVALID_CONFIG,
+        "s3",
+        new Error("Bucket name cannot contain slashes")
+      );
+    }
+    Object.defineProperty(this, "config", {
+      value: config,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  /**
+   * Get safe config info for debugging (no secrets)
+   */
+  getConfigInfo() {
+    return {
+      bucket: this.config.bucket,
+      region: this.config.region,
+      endpoint: this.config.endpoint
+    };
+  }
+  /**
+   * Initializes the S3 client lazily with race condition protection.
+   */
+  async ensureClient() {
+    if (!this.clientPromise) {
+      this.clientPromise = this.initializeClient();
+    }
+    return this.clientPromise;
+  }
+  async initializeClient() {
+    const { S3Client } = await getS3Imports();
+    const client = new S3Client({
+      region: this.config.region,
+      credentials: {
+        accessKeyId: this.config.accessKeyId,
+        secretAccessKey: this.config.secretAccessKey
+      },
+      ...this.config.endpoint && { endpoint: this.config.endpoint },
+      ...this.config.forcePathStyle !== void 0 && { forcePathStyle: this.config.forcePathStyle }
+    });
+    this.client = client;
+    return client;
+  }
+  async upload(file, options) {
+    const client = await this.ensureClient();
+    const Upload = await getUploadClass();
+    try {
+      const key = this.generateKey(options);
+      const { contentType, extension } = await this.getContentType(file);
+      const upload = new Upload({
+        client,
+        params: {
+          Bucket: this.config.bucket,
+          Key: key,
+          Body: file,
+          ContentType: contentType,
+          Metadata: {
+            ...options?.metadata || {},
+            extension
+          }
+        },
+        // Configuration for multipart upload
+        queueSize: 4,
+        // Upload 4 parts in parallel
+        partSize: 5 * 1024 * 1024,
+        // 5MB per part (S3 minimum)
+        leavePartsOnError: false
+        // Auto-cleanup failed uploads
+      });
+      if (options?.onProgress) {
+        upload.on("httpUploadProgress", (progress) => {
+          if (progress.total) {
+            const percentComplete = progress.loaded / progress.total * 100;
+            options.onProgress(percentComplete);
+          }
+        });
+      }
+      await upload.done();
+      const size = file instanceof Buffer ? file.byteLength : file.size;
+      return this.createResult(key, size, extension, options?.metadata);
+    } catch (error) {
+      throw this.mapS3Error(error, core.MediaErrorCode.UPLOAD_FAILED);
+    }
+  }
+  async delete(id) {
+    const client = await this.ensureClient();
+    const { DeleteObjectCommand } = await getS3Imports();
+    try {
+      const command = new DeleteObjectCommand({
+        Bucket: this.config.bucket,
+        Key: id
+      });
+      await client.send(command);
+    } catch (error) {
+      throw this.mapS3Error(error, core.MediaErrorCode.DELETE_FAILED);
+    }
+  }
+  async get(id) {
+    const client = await this.ensureClient();
+    const { HeadObjectCommand } = await getS3Imports();
+    try {
+      const command = new HeadObjectCommand({
+        Bucket: this.config.bucket,
+        Key: id
+      });
+      const response = await client.send(command);
+      const metadata = response.Metadata;
+      return {
+        id,
+        url: this.getUrl(id),
+        publicUrl: this.getUrl(id),
+        size: response.ContentLength ?? 0,
+        format: metadata?.extension || "",
+        provider: this.name,
+        metadata: {
+          contentType: response.ContentType,
+          extension: metadata?.extension
+        },
+        createdAt: response.LastModified ?? /* @__PURE__ */ new Date()
+      };
+    } catch (error) {
+      throw this.mapS3Error(error, core.MediaErrorCode.FILE_NOT_FOUND);
+    }
+  }
+  getUrl(id, _transform) {
+    if (this.config.endpoint) {
+      return `${this.config.endpoint}/${this.config.bucket}/${id}`;
+    }
+    return `https://${this.config.bucket}.s3.${this.config.region}.amazonaws.com/${id}`;
+  }
+  async uploadMultiple(files, options) {
+    const concurrency = options?.concurrency ?? 5;
+    const results = [];
+    let completedCount = 0;
+    for (let i = 0; i < files.length; i += concurrency) {
+      const batch = files.slice(i, i + concurrency);
+      const batchResults = await Promise.all(
+        batch.map((file) => {
+          const { concurrency: _, onBatchProgress: __, ...uploadOptions } = options ?? {};
+          return this.upload(
+            file,
+            Object.keys(uploadOptions).length > 0 ? uploadOptions : void 0
+          ).then((result) => {
+            completedCount++;
+            options?.onBatchProgress?.(completedCount, files.length);
+            return result;
+          });
+        })
+      );
+      results.push(...batchResults);
+    }
+    return results;
+  }
+  async deleteMultiple(ids) {
+    const concurrency = 10;
+    const failed = [];
+    for (let i = 0; i < ids.length; i += concurrency) {
+      const batch = ids.slice(i, i + concurrency);
+      const results = await Promise.allSettled(
+        batch.map((id) => this.delete(id).then(() => ({ id })))
+      );
+      results.forEach((result, index) => {
+        const id = batch[index];
+        if (result.status === "rejected") {
+          failed.push({ id, error: result.reason });
+        }
+      });
+    }
+    if (failed.length > 0) {
+      throw core.createMediaError(
+        core.MediaErrorCode.DELETE_FAILED,
+        this.name,
+        new Error(
+          `Failed to delete ${failed.length} of ${ids.length} files: ${failed.map((f) => f.id).join(", ")}`
+        )
+      );
+    }
+  }
+  /**
+   * Access to the native AWS S3 client.
+   * Returns the full S3Client with all methods and types.
+   */
+  get native() {
+    return this.client;
+  }
+  // Prevent credential exposure in serialization
+  toJSON() {
+    return {
+      name: this.name,
+      features: this.features
+    };
+  }
+  generateKey(options) {
+    const baseFilename = options?.filename ?? this.generateRandomId();
+    const shouldMakeUnique = options?.uniqueFilename !== false;
+    const filename = shouldMakeUnique && options?.filename ? `${baseFilename}-${this.generateShortId()}` : baseFilename;
+    const folder = options?.folder ? `${options.folder}/` : "";
+    return `${folder}${filename}`;
+  }
+  generateRandomId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+  }
+  generateShortId() {
+    const cryptoObj = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+    if (cryptoObj?.getRandomValues) {
+      const buffer = new Uint8Array(6);
+      cryptoObj.getRandomValues(buffer);
+      return Array.from(buffer).map((b) => b.toString(36).padStart(2, "0")).join("").substring(0, 8);
+    }
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return `${timestamp}${random}`.substring(0, 12);
+  }
+  async getContentType(file) {
+    if (file instanceof Buffer) {
+      const detected = await core.getFileType(file);
+      return { contentType: detected?.mime ?? "application/octet-stream", extension: detected?.ext ?? "" };
+    }
+    return { contentType: file.type || "application/octet-stream", extension: file.name.split(".").pop() || "" };
+  }
+  createResult(key, size, extension, metadata) {
+    return {
+      id: key,
+      url: this.getUrl(key),
+      publicUrl: this.getUrl(key),
+      size,
+      format: extension,
+      provider: this.name,
+      metadata: metadata || {},
+      createdAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Maps S3-specific errors to MediaError with appropriate codes
+   */
+  mapS3Error(error, defaultCode) {
+    const err = error;
+    const httpCode = err.$metadata?.httpStatusCode;
+    if (err.name === "NoSuchBucket") {
+      throw core.createMediaError(
+        core.MediaErrorCode.INVALID_CONFIG,
+        this.name,
+        new Error(`Bucket '${this.config.bucket}' does not exist`)
+      );
+    }
+    if (err.name === "AccessDenied" || err.name === "InvalidAccessKeyId" || httpCode === 403) {
+      throw core.createMediaError(
+        core.MediaErrorCode.UNAUTHORIZED,
+        this.name,
+        new Error("Access denied - check S3 credentials and bucket permissions")
+      );
+    }
+    if (err.name === "SignatureDoesNotMatch" || httpCode === 401) {
+      throw core.createMediaError(
+        core.MediaErrorCode.INVALID_CREDENTIALS,
+        this.name,
+        new Error("Invalid AWS credentials - check accessKeyId and secretAccessKey")
+      );
+    }
+    if (err.name === "NoSuchKey" || httpCode === 404) {
+      throw core.createMediaError(core.MediaErrorCode.FILE_NOT_FOUND, this.name, error);
+    }
+    if (err.name === "SlowDown" || err.name === "ServiceUnavailable" || httpCode === 503) {
+      throw core.createMediaError(
+        core.MediaErrorCode.NETWORK_ERROR,
+        this.name,
+        new Error("AWS S3 service temporarily unavailable or rate limited - try again later")
+      );
+    }
+    if (err.name === "TimeoutError" || err.message?.includes("ETIMEDOUT") || err.message?.includes("ECONNRESET")) {
+      throw core.createMediaError(
+        core.MediaErrorCode.NETWORK_ERROR,
+        this.name,
+        new Error("Network timeout - check connection or try smaller file")
+      );
+    }
+    if (err.name === "EntityTooLarge" || httpCode === 413) {
+      throw core.createMediaError(
+        core.MediaErrorCode.FILE_TOO_LARGE,
+        this.name,
+        new Error("File exceeds maximum allowed size")
+      );
+    }
+    throw core.createMediaError(defaultCode, this.name, error);
+  }
 };
 
-//#endregion
 exports.S3Features = S3Features;
 exports.S3Provider = S3Provider;
-//# sourceMappingURL=index.cjs.map