@kumix/storage 0.1.0

package/dist/s3.js

@@ -0,0 +1,779 @@
+import { s as loadS3Config } from "./config-t-NVJICl.js";
+import { buildPublicUrl, getMimeType } from "./helpers.js";
+import { CopyObjectCommand, DeleteObjectCommand, DeleteObjectsCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+//#region src/operations/file-operations.ts
+/**
+* S3 file operations implementation
+* Provides comprehensive file management operations for S3-compatible storage providers
+*/
+/**
+* S3 file operations implementation
+* Handles all file-related operations for S3-compatible storage providers
+* @internal
+*/
+var FileOperations = class {
+	client;
+	config;
+	constructor(client, config) {
+		this.client = client;
+		this.config = config;
+	}
+	async upload(options) {
+		try {
+			const contentType = options.contentType || getMimeType(options.key);
+			const command = new PutObjectCommand({
+				Bucket: this.config.bucket,
+				Key: options.key,
+				Body: options.file,
+				ContentType: contentType,
+				Metadata: options.metadata,
+				CacheControl: options.cacheControl,
+				ContentDisposition: options.contentDisposition,
+				ACL: options.acl,
+				Expires: options.expires
+			});
+			const result = await this.client.send(command);
+			const publicUrl = this.getPublicUrl(options.key);
+			return {
+				success: true,
+				key: options.key,
+				url: publicUrl,
+				publicUrl,
+				etag: result.ETag?.replace(/"/g, ""),
+				size: typeof options.file === "string" ? Buffer.byteLength(options.file, "utf8") : options.file.length
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Upload failed"
+			};
+		}
+	}
+	async download(options) {
+		try {
+			const command = new GetObjectCommand({
+				Bucket: this.config.bucket,
+				Key: options.key,
+				Range: options.range
+			});
+			const result = await this.client.send(command);
+			if (!result.Body) return {
+				success: false,
+				error: "No data received"
+			};
+			const chunks = [];
+			const reader = result.Body.transformToWebStream().getReader();
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				chunks.push(value);
+			}
+			const data = Buffer.concat(chunks);
+			return {
+				success: true,
+				content: data,
+				data,
+				contentType: result.ContentType,
+				contentLength: result.ContentLength,
+				lastModified: result.LastModified,
+				etag: result.ETag?.replace(/"/g, ""),
+				metadata: result.Metadata
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Download failed"
+			};
+		}
+	}
+	async delete(options) {
+		try {
+			const command = new DeleteObjectCommand({
+				Bucket: this.config.bucket,
+				Key: options.key
+			});
+			await this.client.send(command);
+			return { success: true };
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Delete failed"
+			};
+		}
+	}
+	async batchDelete(options) {
+		try {
+			const command = new DeleteObjectsCommand({
+				Bucket: this.config.bucket,
+				Delete: {
+					Objects: options.keys.map((key) => ({ Key: key })),
+					Quiet: false
+				}
+			});
+			const result = await this.client.send(command);
+			const deleted = result.Deleted?.map((obj) => obj.Key).filter(Boolean);
+			const errors = result.Errors?.map((err) => ({
+				key: err.Key || "",
+				error: err.Message || "Unknown error"
+			})) || [];
+			return {
+				success: true,
+				deleted,
+				errors: errors.length > 0 ? errors : void 0
+			};
+		} catch (error) {
+			return {
+				success: false,
+				errors: options.keys.map((key) => ({
+					key,
+					error: error instanceof Error ? error.message : "Batch delete failed"
+				}))
+			};
+		}
+	}
+	async list(options = {}) {
+		try {
+			const command = new ListObjectsV2Command({
+				Bucket: this.config.bucket,
+				Prefix: options.prefix,
+				Delimiter: options.delimiter,
+				MaxKeys: options.maxKeys,
+				ContinuationToken: options.continuationToken
+			});
+			const result = await this.client.send(command);
+			return {
+				success: true,
+				files: result.Contents?.map((obj) => ({
+					key: obj.Key,
+					size: obj.Size || 0,
+					lastModified: obj.LastModified || /* @__PURE__ */ new Date(),
+					etag: obj.ETag?.replace(/"/g, "") || "",
+					contentType: getMimeType(obj.Key)
+				})) || [],
+				isTruncated: result.IsTruncated,
+				nextContinuationToken: result.NextContinuationToken,
+				commonPrefixes: result.CommonPrefixes?.map((cp) => cp.Prefix)
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "List failed"
+			};
+		}
+	}
+	async exists(key) {
+		try {
+			const command = new HeadObjectCommand({
+				Bucket: this.config.bucket,
+				Key: key
+			});
+			const result = await this.client.send(command);
+			return {
+				exists: true,
+				fileInfo: {
+					key,
+					size: result.ContentLength || 0,
+					lastModified: result.LastModified || /* @__PURE__ */ new Date(),
+					etag: result.ETag?.replace(/"/g, "") || "",
+					contentType: result.ContentType,
+					metadata: result.Metadata
+				}
+			};
+		} catch (error) {
+			if (error instanceof Error && error.name === "NotFound") return { exists: false };
+			return {
+				exists: false,
+				error: error instanceof Error ? error.message : "Check existence failed"
+			};
+		}
+	}
+	async copy(options) {
+		try {
+			const command = new CopyObjectCommand({
+				Bucket: this.config.bucket,
+				CopySource: `${this.config.bucket}/${options.sourceKey}`,
+				Key: options.destinationKey,
+				Metadata: options.metadata,
+				MetadataDirective: options.metadataDirective || "COPY"
+			});
+			return {
+				success: true,
+				etag: (await this.client.send(command)).CopyObjectResult?.ETag?.replace(/"/g, "")
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Copy failed"
+			};
+		}
+	}
+	async move(options) {
+		try {
+			const copyResult = await this.copy({
+				sourceKey: options.sourceKey,
+				destinationKey: options.destinationKey,
+				metadata: options.metadata,
+				metadataDirective: options.metadataDirective
+			});
+			if (!copyResult.success) return {
+				success: false,
+				error: copyResult.error || "Move failed during copy operation"
+			};
+			const deleteResult = await this.delete({ key: options.sourceKey });
+			if (!deleteResult.success) return {
+				success: false,
+				error: deleteResult.error || "Move failed during delete operation"
+			};
+			return {
+				success: true,
+				etag: copyResult.etag
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Move failed"
+			};
+		}
+	}
+	async duplicate(options) {
+		return this.copy(options);
+	}
+	async getPresignedUrl(options) {
+		try {
+			const expiresIn = options.expiresIn || 3600;
+			let command;
+			if (options.operation === "get") command = new GetObjectCommand({
+				Bucket: this.config.bucket,
+				Key: options.key
+			});
+			else command = new PutObjectCommand({
+				Bucket: this.config.bucket,
+				Key: options.key,
+				ContentType: options.contentType
+			});
+			return {
+				success: true,
+				url: await getSignedUrl(this.client, command, { expiresIn }),
+				expiresAt: new Date(Date.now() + expiresIn * 1e3)
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Presigned URL generation failed"
+			};
+		}
+	}
+	getPublicUrl(key) {
+		const isCloudflare = this.config.provider === "cloudflare-r2";
+		const isSupabase = this.config.provider === "supabase";
+		if (this.config.publicUrl) return buildPublicUrl(this.config.publicUrl, isCloudflare ? "" : this.config.bucket, key, isSupabase);
+		if (this.config.endpoint) return buildPublicUrl(this.config.endpoint, this.config.bucket, key, isSupabase);
+		return `https://${this.config.bucket}.s3.${this.config.region}.amazonaws.com/${key}`;
+	}
+};
+//#endregion
+//#region src/operations/folder-operations.ts
+/**
+* S3 folder operations implementation
+* Provides comprehensive folder management operations for S3-compatible storage providers
+*/
+/**
+* S3 folder operations implementation
+* Handles all folder-related operations for S3-compatible storage providers
+* @internal
+*/
+var FolderOperations = class {
+	client;
+	config;
+	constructor(client, config) {
+		this.client = client;
+		this.config = config;
+	}
+	async createFolder(options) {
+		try {
+			const folderPath = options.path.endsWith("/") ? options.path : `${options.path}/`;
+			const command = new PutObjectCommand({
+				Bucket: this.config.bucket,
+				Key: folderPath,
+				Body: "",
+				ContentType: "application/x-directory"
+			});
+			await this.client.send(command);
+			return {
+				success: true,
+				path: folderPath
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Create folder failed"
+			};
+		}
+	}
+	async deleteFolder(options) {
+		try {
+			const folderPath = options.path.endsWith("/") ? options.path : `${options.path}/`;
+			if (options.recursive) {
+				const listCommand = new ListObjectsV2Command({
+					Bucket: this.config.bucket,
+					Prefix: folderPath
+				});
+				const listResult = await this.client.send(listCommand);
+				if (!listResult.Contents || listResult.Contents.length === 0) return {
+					success: true,
+					deletedFiles: []
+				};
+				const deleteCommand = new DeleteObjectsCommand({
+					Bucket: this.config.bucket,
+					Delete: {
+						Objects: listResult.Contents.map((obj) => ({ Key: obj.Key })),
+						Quiet: false
+					}
+				});
+				return {
+					success: true,
+					deletedFiles: (await this.client.send(deleteCommand)).Deleted?.map((obj) => obj.Key).filter(Boolean) || []
+				};
+			} else {
+				const deleteCommand = new DeleteObjectsCommand({
+					Bucket: this.config.bucket,
+					Delete: {
+						Objects: [{ Key: folderPath }],
+						Quiet: false
+					}
+				});
+				await this.client.send(deleteCommand);
+				return {
+					success: true,
+					deletedFiles: [folderPath]
+				};
+			}
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Delete folder failed"
+			};
+		}
+	}
+	async listFolders(options = {}) {
+		try {
+			const command = new ListObjectsV2Command({
+				Bucket: this.config.bucket,
+				Prefix: options.prefix,
+				Delimiter: options.delimiter || "/",
+				MaxKeys: options.maxKeys,
+				ContinuationToken: options.continuationToken
+			});
+			const result = await this.client.send(command);
+			return {
+				success: true,
+				folders: result.CommonPrefixes?.map((cp) => {
+					const path = cp.Prefix;
+					return {
+						name: path.split("/").filter(Boolean).pop() || "",
+						path,
+						size: 0,
+						fileCount: 0,
+						lastModified: /* @__PURE__ */ new Date()
+					};
+				}) || [],
+				files: result.Contents?.map((obj) => ({
+					key: obj.Key,
+					size: obj.Size || 0,
+					lastModified: obj.LastModified || /* @__PURE__ */ new Date(),
+					etag: obj.ETag?.replace(/"/g, "") || "",
+					contentType: getMimeType(obj.Key)
+				})) || [],
+				isTruncated: result.IsTruncated,
+				nextContinuationToken: result.NextContinuationToken
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "List folders failed"
+			};
+		}
+	}
+	async folderExists(path) {
+		try {
+			const folderPath = path.endsWith("/") ? path : `${path}/`;
+			const command = new ListObjectsV2Command({
+				Bucket: this.config.bucket,
+				Prefix: folderPath,
+				MaxKeys: 1
+			});
+			const result = await this.client.send(command);
+			if (result.Contents && result.Contents.length > 0 || result.CommonPrefixes && result.CommonPrefixes.length > 0) return {
+				exists: true,
+				folderInfo: {
+					name: folderPath.split("/").filter(Boolean).pop() || "",
+					path: folderPath,
+					size: 0,
+					fileCount: 0,
+					lastModified: /* @__PURE__ */ new Date()
+				}
+			};
+			return { exists: false };
+		} catch (error) {
+			return {
+				exists: false,
+				error: error instanceof Error ? error.message : "Check folder existence failed"
+			};
+		}
+	}
+	async renameFolder(options) {
+		try {
+			const oldPath = options.oldPath.endsWith("/") ? options.oldPath : `${options.oldPath}/`;
+			const newPath = options.newPath.endsWith("/") ? options.newPath : `${options.newPath}/`;
+			const listCommand = new ListObjectsV2Command({
+				Bucket: this.config.bucket,
+				Prefix: oldPath
+			});
+			const listResult = await this.client.send(listCommand);
+			if (!listResult.Contents || listResult.Contents.length === 0) return {
+				success: true,
+				movedFiles: []
+			};
+			const movedFiles = [];
+			for (const obj of listResult.Contents) {
+				const oldKey = obj.Key;
+				const newKey = oldKey.replace(oldPath, newPath);
+				const copyCommand = new CopyObjectCommand({
+					Bucket: this.config.bucket,
+					Key: newKey,
+					CopySource: `${this.config.bucket}/${oldKey}`
+				});
+				await this.client.send(copyCommand);
+				movedFiles.push(newKey);
+			}
+			const deleteCommand = new DeleteObjectsCommand({
+				Bucket: this.config.bucket,
+				Delete: {
+					Objects: listResult.Contents.map((obj) => ({ Key: obj.Key })),
+					Quiet: true
+				}
+			});
+			await this.client.send(deleteCommand);
+			return {
+				success: true,
+				movedFiles
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Rename folder failed"
+			};
+		}
+	}
+	async copyFolder(options) {
+		try {
+			const sourcePath = options.sourcePath.endsWith("/") ? options.sourcePath : `${options.sourcePath}/`;
+			const destPath = options.destinationPath.endsWith("/") ? options.destinationPath : `${options.destinationPath}/`;
+			const listCommand = new ListObjectsV2Command({
+				Bucket: this.config.bucket,
+				Prefix: sourcePath
+			});
+			const listResult = await this.client.send(listCommand);
+			if (!listResult.Contents || listResult.Contents.length === 0) return {
+				success: true,
+				copiedFiles: []
+			};
+			const copiedFiles = [];
+			for (const obj of listResult.Contents) {
+				const sourceKey = obj.Key;
+				const destKey = sourceKey.replace(sourcePath, destPath);
+				const copyCommand = new CopyObjectCommand({
+					Bucket: this.config.bucket,
+					Key: destKey,
+					CopySource: `${this.config.bucket}/${sourceKey}`
+				});
+				await this.client.send(copyCommand);
+				copiedFiles.push(destKey);
+			}
+			return {
+				success: true,
+				copiedFiles
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Copy folder failed"
+			};
+		}
+	}
+};
+//#endregion
+//#region src/providers/s3.ts
+/**
+* S3-compatible storage provider implementation
+* Provides cloud storage operations using AWS S3 SDK for S3-compatible services
+*/
+/**
+* S3-compatible storage provider
+* Implements StorageInterface for AWS S3 and S3-compatible services
+* @internal
+*/
+var S3Provider = class {
+	client;
+	config;
+	fileOps;
+	folderOps;
+	constructor(config) {
+		this.config = config;
+		this.client = new S3Client({
+			region: config.region,
+			credentials: {
+				accessKeyId: config.accessKeyId,
+				secretAccessKey: config.secretAccessKey
+			},
+			endpoint: config.endpoint,
+			forcePathStyle: config.forcePathStyle || false
+		});
+		this.fileOps = new FileOperations(this.client, this.config);
+		this.folderOps = new FolderOperations(this.client, this.config);
+	}
+	async upload(options) {
+		return this.fileOps.upload(options);
+	}
+	async download(options) {
+		return this.fileOps.download(options);
+	}
+	async delete(options) {
+		return this.fileOps.delete(options);
+	}
+	async batchDelete(options) {
+		return this.fileOps.batchDelete(options);
+	}
+	async list(options) {
+		return this.fileOps.list(options);
+	}
+	async exists(key) {
+		return this.fileOps.exists(key);
+	}
+	async copy(options) {
+		return this.fileOps.copy(options);
+	}
+	async move(options) {
+		return this.fileOps.move(options);
+	}
+	async duplicate(options) {
+		return this.fileOps.duplicate(options);
+	}
+	async getPresignedUrl(options) {
+		return this.fileOps.getPresignedUrl(options);
+	}
+	getPublicUrl(key) {
+		return this.fileOps.getPublicUrl(key);
+	}
+	async createFolder(options) {
+		return this.folderOps.createFolder(options);
+	}
+	async deleteFolder(options) {
+		return this.folderOps.deleteFolder(options);
+	}
+	async listFolders(options) {
+		return this.folderOps.listFolders(options);
+	}
+	async folderExists(path) {
+		return this.folderOps.folderExists(path);
+	}
+	async renameFolder(options) {
+		return this.folderOps.renameFolder(options);
+	}
+	async copyFolder(options) {
+		return this.folderOps.copyFolder(options);
+	}
+};
+//#endregion
+//#region src/services/s3.ts
+/**
+* S3 storage service implementation
+* High-level service wrapper for S3-compatible storage operations with convenience methods
+*/
+/**
+* S3 storage service
+* High-level service for S3-compatible storage operations with convenience methods
+* @public
+*/
+var S3Service = class {
+	provider;
+	config;
+	constructor(config) {
+		this.config = config || loadS3Config();
+		this.provider = this.createProvider(this.config);
+	}
+	createProvider(config) {
+		switch (config.provider) {
+			case "aws":
+			case "cloudflare-r2":
+			case "minio":
+			case "digitalocean":
+			case "supabase":
+			case "custom": return new S3Provider(config);
+			default: throw new Error(`Unsupported S3 provider: ${config.provider}`);
+		}
+	}
+	getConfig() {
+		return { ...this.config };
+	}
+	getBucket() {
+		return this.config.bucket;
+	}
+	getRegion() {
+		return this.config.region;
+	}
+	getProvider() {
+		return this.config.provider;
+	}
+	getPublicUrl(key) {
+		return this.provider.getPublicUrl(key);
+	}
+	async upload(options) {
+		return this.provider.upload(options);
+	}
+	async download(options) {
+		return this.provider.download(options);
+	}
+	async delete(options) {
+		return this.provider.delete(options);
+	}
+	async batchDelete(options) {
+		return this.provider.batchDelete(options);
+	}
+	async list(options) {
+		return this.provider.list(options);
+	}
+	async exists(key) {
+		return this.provider.exists(key);
+	}
+	async copy(options) {
+		return this.provider.copy(options);
+	}
+	async move(options) {
+		return this.provider.move(options);
+	}
+	async duplicate(options) {
+		return this.provider.duplicate(options);
+	}
+	async getPresignedUrl(options) {
+		return this.provider.getPresignedUrl(options);
+	}
+	async createFolder(options) {
+		return this.provider.createFolder(options);
+	}
+	async deleteFolder(options) {
+		return this.provider.deleteFolder(options);
+	}
+	async listFolders(options) {
+		return this.provider.listFolders(options);
+	}
+	async folderExists(path) {
+		return this.provider.folderExists(path);
+	}
+	async renameFolder(options) {
+		return this.provider.renameFolder(options);
+	}
+	async copyFolder(options) {
+		return this.provider.copyFolder(options);
+	}
+	async uploadFile(key, file, options) {
+		return this.upload({
+			key,
+			file,
+			...options
+		});
+	}
+	async downloadFile(key) {
+		return this.download({ key });
+	}
+	async deleteFile(key) {
+		return this.delete({ key });
+	}
+	async deleteFiles(keys) {
+		return this.batchDelete({ keys });
+	}
+	async listFiles(prefix, maxKeys) {
+		return this.list({
+			prefix,
+			maxKeys
+		});
+	}
+	async fileExists(key) {
+		return (await this.exists(key)).exists;
+	}
+	async copyFile(sourceKey, destinationKey, options) {
+		return this.copy({
+			sourceKey,
+			destinationKey,
+			...options
+		});
+	}
+	async moveFile(sourceKey, destinationKey, options) {
+		return this.move({
+			sourceKey,
+			destinationKey,
+			...options
+		});
+	}
+	async duplicateFile(sourceKey, destinationKey, options) {
+		return this.duplicate({
+			sourceKey,
+			destinationKey,
+			...options
+		});
+	}
+	async renameFile(sourceKey, newKey, options) {
+		return this.moveFile(sourceKey, newKey, options);
+	}
+	async getDownloadUrl(key, expiresIn) {
+		return this.getPresignedUrl({
+			key,
+			operation: "get",
+			expiresIn
+		});
+	}
+	async getUploadUrl(key, contentType, expiresIn) {
+		return this.getPresignedUrl({
+			key,
+			operation: "put",
+			contentType,
+			expiresIn
+		});
+	}
+	async createFolderPath(path) {
+		return this.createFolder({ path });
+	}
+	async deleteFolderPath(path, recursive = false) {
+		return this.deleteFolder({
+			path,
+			recursive
+		});
+	}
+	async folderPathExists(path) {
+		return (await this.folderExists(path)).exists;
+	}
+	async renameFolderPath(oldPath, newPath) {
+		return this.renameFolder({
+			oldPath,
+			newPath
+		});
+	}
+	async copyFolderPath(sourcePath, destinationPath, recursive = true) {
+		return this.copyFolder({
+			sourcePath,
+			destinationPath,
+			recursive
+		});
+	}
+};
+//#endregion
+//#region src/s3.ts
+function createS3(config, env) {
+	if (config) return new S3Service(config);
+	return new S3Service(loadS3Config(env));
+}
+//#endregion
+export { S3Service, createS3 };
+
+//# sourceMappingURL=s3.js.map