@settlemint/sdk-minio 2.3.2-prfd3a56ad → 2.3.3

package/dist/minio.cjs

@@ -1,302 +1,549 @@
-"use strict";
+//#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 __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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));
 
-// src/minio.ts
-var minio_exports = {};
-__export(minio_exports, {
-  DEFAULT_BUCKET: () => DEFAULT_BUCKET,
-  createPresignedUploadUrl: () => createPresignedUploadUrl,
-  createServerMinioClient: () => createServerMinioClient,
-  deleteFile: () => deleteFile,
-  getFileById: () => getFileById,
-  getFilesList: () => getFilesList,
-  uploadFile: () => uploadFile
-});
-module.exports = __toCommonJS(minio_exports);
-var import_runtime3 = require("@settlemint/sdk-utils/runtime");
-var import_validation3 = require("@settlemint/sdk-utils/validation");
-var import_minio = require("minio");
+//#endregion
+const __settlemint_sdk_utils_runtime = __toESM(require("@settlemint/sdk-utils/runtime"));
+const __settlemint_sdk_utils_validation = __toESM(require("@settlemint/sdk-utils/validation"));
+const minio = __toESM(require("minio"));
+const zod_v4 = __toESM(require("zod/v4"));
 
-// src/helpers/client-options.schema.ts
-var import_validation = require("@settlemint/sdk-utils/validation");
-var import_v4 = require("zod/v4");
-var ServerClientOptionsSchema = import_v4.z.object({
-  /** The URL of the MinIO instance to connect to */
-  instance: import_validation.UrlSchema,
-  /** The MinIO access key used to authenticate with the MinIO server */
-  accessKey: import_v4.z.string(),
-  /** The MinIO secret key used to authenticate with the MinIO server */
-  secretKey: import_v4.z.string()
+//#region src/helpers/client-options.schema.ts
+/**
+* Schema for validating server client options for the MinIO client.
+*/
+const ServerClientOptionsSchema = zod_v4.z.object({
+	instance: __settlemint_sdk_utils_validation.UrlSchema,
+	accessKey: zod_v4.z.string().min(1, "Access key cannot be empty"),
+	secretKey: zod_v4.z.string().min(1, "Secret key cannot be empty")
 });
 
-// src/helpers/schema.ts
-var import_v42 = require("zod/v4");
-var FileMetadataSchema = import_v42.z.object({
-  id: import_v42.z.string(),
-  name: import_v42.z.string(),
-  contentType: import_v42.z.string(),
-  size: import_v42.z.number(),
-  uploadedAt: import_v42.z.string().datetime(),
-  etag: import_v42.z.string(),
-  url: import_v42.z.string().url().optional()
+//#endregion
+//#region src/helpers/schema.ts
+/**
+* Schema for file metadata stored in MinIO.
+* Defines the structure and validation rules for file information.
+*/
+const FileMetadataSchema = zod_v4.z.object({
+	id: zod_v4.z.string(),
+	name: zod_v4.z.string(),
+	contentType: zod_v4.z.string(),
+	size: zod_v4.z.number(),
+	uploadedAt: zod_v4.z.string().datetime(),
+	etag: zod_v4.z.string(),
+	url: zod_v4.z.string().url().optional()
 });
-var DEFAULT_BUCKET = "uploads";
-
-// src/helpers/functions.ts
-var import_runtime2 = require("@settlemint/sdk-utils/runtime");
-var import_validation2 = require("@settlemint/sdk-utils/validation");
+/**
+* Default bucket name to use for file storage when none is specified.
+*/
+const DEFAULT_BUCKET = "uploads";
 
-// src/helpers/executor.ts
-var import_runtime = require("@settlemint/sdk-utils/runtime");
+//#endregion
+//#region src/helpers/executor.ts
+/**
+* Executes a MinIO operation using the provided client
+*
+* @param client - MinIO client to use
+* @param operation - The operation to execute
+* @returns The result of the operation execution
+* @throws Will throw an error if the operation fails
+*
+* @example
+* import { createServerMinioClient, createListObjectsOperation, executeMinioOperation } from "@settlemint/sdk-minio";
+* const { client } = createServerMinioClient({
+*   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+*   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+*   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+* });
+* const listOperation = createListObjectsOperation("my-bucket", "prefix/");
+* const result = await executeMinioOperation(client, listOperation);
+*/
 async function executeMinioOperation(client, operation) {
-  (0, import_runtime.ensureServer)();
-  return operation.execute(client);
+	(0, __settlemint_sdk_utils_runtime.ensureServer)();
+	return operation.execute(client);
 }
 
-// src/helpers/operations.ts
+//#endregion
+//#region src/helpers/operations.ts
+/**
+* Creates an operation to list objects in a bucket
+*
+* @param bucket - The bucket name to list objects from
+* @param prefix - Optional prefix to filter objects (like a folder path)
+* @returns A MinioOperation that lists objects when executed
+* @throws Will throw an error if the operation fails
+*
+* @example
+* import { createListObjectsOperation, executeMinioOperation } from "@settlemint/sdk-minio";
+*
+* const listOperation = createListObjectsOperation("my-bucket", "folder/");
+* const objects = await executeMinioOperation(client, listOperation);
+*/
 function createListObjectsOperation(bucket, prefix = "") {
-  return {
-    execute: async (client) => {
-      const objectsStream = client.listObjects(bucket, prefix, true);
-      const objects = [];
-      return new Promise((resolve, reject) => {
-        objectsStream.on("data", (obj) => {
-          if (obj.name && typeof obj.size === "number" && obj.etag && obj.lastModified) {
-            objects.push({
-              name: obj.name,
-              prefix: obj.prefix,
-              size: obj.size,
-              etag: obj.etag,
-              lastModified: obj.lastModified
-            });
-          }
-        });
-        objectsStream.on("error", (err) => {
-          reject(err);
-        });
-        objectsStream.on("end", () => {
-          resolve(objects);
-        });
-      });
-    }
-  };
+	return { execute: async (client) => {
+		const objectsStream = client.listObjects(bucket, prefix, true);
+		const objects = [];
+		return new Promise((resolve, reject) => {
+			objectsStream.on("data", (obj) => {
+				if (obj.name && typeof obj.size === "number" && obj.etag && obj.lastModified) {
+					objects.push({
+						name: obj.name,
+						prefix: obj.prefix,
+						size: obj.size,
+						etag: obj.etag,
+						lastModified: obj.lastModified
+					});
+				}
+			});
+			objectsStream.on("error", (err) => {
+				reject(err);
+			});
+			objectsStream.on("end", () => {
+				resolve(objects);
+			});
+		});
+	} };
 }
+/**
+* Creates an operation to get an object's metadata
+*
+* @param bucket - The bucket name containing the object
+* @param objectName - The object name/path
+* @returns A MinioOperation that gets object stats when executed
+* @throws Will throw an error if the operation fails
+*
+* @example
+* import { createStatObjectOperation, executeMinioOperation } from "@settlemint/sdk-minio";
+*
+* const statOperation = createStatObjectOperation("my-bucket", "folder/file.txt");
+* const stats = await executeMinioOperation(client, statOperation);
+*/
 function createStatObjectOperation(bucket, objectName) {
-  return {
-    execute: async (client) => {
-      return client.statObject(bucket, objectName);
-    }
-  };
+	return { execute: async (client) => {
+		return client.statObject(bucket, objectName);
+	} };
 }
+/**
+* Creates an operation to upload a buffer to MinIO
+*
+* @param bucket - The bucket name to upload to
+* @param objectName - The object name/path to create
+* @param buffer - The buffer containing the file data
+* @param metadata - Optional metadata to attach to the object
+* @returns A MinioOperation that uploads the buffer when executed
+* @throws Will throw an error if the operation fails
+*
+* @example
+* import { createUploadOperation, executeMinioOperation } from "@settlemint/sdk-minio";
+*
+* const buffer = Buffer.from("file content");
+* const uploadOperation = createUploadOperation("my-bucket", "folder/file.txt", buffer, { "content-type": "text/plain" });
+* const result = await executeMinioOperation(client, uploadOperation);
+*/
+function createUploadOperation(bucket, objectName, buffer, metadata) {
+	return { execute: async (client) => {
+		return client.putObject(bucket, objectName, buffer, undefined, metadata);
+	} };
+}
+/**
+* Creates an operation to delete an object from MinIO
+*
+* @param bucket - The bucket name containing the object
+* @param objectName - The object name/path to delete
+* @returns A MinioOperation that deletes the object when executed
+* @throws Will throw an error if the operation fails
+*
+* @example
+* import { createDeleteOperation, executeMinioOperation } from "@settlemint/sdk-minio";
+*
+* const deleteOperation = createDeleteOperation("my-bucket", "folder/file.txt");
+* await executeMinioOperation(client, deleteOperation);
+*/
 function createDeleteOperation(bucket, objectName) {
-  return {
-    execute: async (client) => {
-      return client.removeObject(bucket, objectName);
-    }
-  };
+	return { execute: async (client) => {
+		return client.removeObject(bucket, objectName);
+	} };
 }
+/**
+* Creates an operation to generate a presigned URL for an object
+*
+* @param bucket - The bucket name containing the object
+* @param objectName - The object name/path
+* @param expirySeconds - How long the URL should be valid for in seconds
+* @returns A MinioOperation that creates a presigned URL when executed
+* @throws Will throw an error if the operation fails
+*
+* @example
+* import { createPresignedUrlOperation, executeMinioOperation } from "@settlemint/sdk-minio";
+*
+* const urlOperation = createPresignedUrlOperation("my-bucket", "folder/file.txt", 3600);
+* const url = await executeMinioOperation(client, urlOperation);
+*/
 function createPresignedUrlOperation(bucket, objectName, expirySeconds) {
-  return {
-    execute: async (client) => {
-      return client.presignedGetObject(bucket, objectName, expirySeconds);
-    }
-  };
+	return { execute: async (client) => {
+		return client.presignedGetObject(bucket, objectName, expirySeconds);
+	} };
 }
+/**
+* Creates an operation to generate a presigned PUT URL for direct uploads
+*
+* @param bucket - The bucket name to upload to
+* @param objectName - The object name/path to create
+* @param expirySeconds - How long the URL should be valid for in seconds
+* @returns A MinioOperation that creates a presigned PUT URL when executed
+* @throws Will throw an error if the operation fails
+*
+* @example
+* import { createPresignedPutOperation, executeMinioOperation } from "@settlemint/sdk-minio";
+*
+* const putUrlOperation = createPresignedPutOperation("my-bucket", "folder/file.txt", 3600);
+* const url = await executeMinioOperation(client, putUrlOperation);
+*/
 function createPresignedPutOperation(bucket, objectName, expirySeconds) {
-  return {
-    execute: async (client) => {
-      return client.presignedPutObject(bucket, objectName, expirySeconds);
-    }
-  };
+	return { execute: async (client) => {
+		return client.presignedPutObject(bucket, objectName, expirySeconds);
+	} };
 }
+/**
+* Creates a simplified upload function bound to a specific client
+*
+* @param client - The MinIO client to use for uploads
+* @returns A function that uploads buffers to MinIO
+* @throws Will throw an error if the operation fails
+*
+* @example
+* import { createSimpleUploadOperation, getMinioClient } from "@settlemint/sdk-minio";
+*
+* const client = await getMinioClient();
+* const uploadFn = createSimpleUploadOperation(client);
+* const result = await uploadFn(buffer, "my-bucket", "folder/file.txt", { "content-type": "text/plain" });
+*/
 function createSimpleUploadOperation(client) {
-  return async (buffer, bucket, objectName, metadata) => {
-    return client.putObject(bucket, objectName, buffer, void 0, metadata);
-  };
+	return async (buffer, bucket, objectName, metadata) => {
+		return client.putObject(bucket, objectName, buffer, undefined, metadata);
+	};
 }
 
-// src/helpers/functions.ts
+//#endregion
+//#region src/helpers/functions.ts
+/**
+* Helper function to normalize paths and prevent double slashes
+*
+* @param path - The path to normalize
+* @param fileName - The filename to append
+* @returns The normalized path with filename
+* @throws Will throw an error if the path is too long (max 1000 characters)
+*/
 function normalizePath(path, fileName) {
-  if (path.length > 1e3) {
-    throw new Error("Path is too long");
-  }
-  const cleanPath = path.replace(/\/+$/, "");
-  if (!cleanPath) {
-    return fileName;
-  }
-  return `${cleanPath}/${fileName}`;
+	if (path.length > 1e3) {
+		throw new Error("Path is too long");
+	}
+	const cleanPath = path.replace(/\/+$/, "");
+	if (!cleanPath) {
+		return fileName;
+	}
+	return `${cleanPath}/${fileName}`;
 }
+/**
+* Gets a list of files with optional prefix filter
+*
+* @param client - The MinIO client to use
+* @param prefix - Optional prefix to filter files (like a folder path)
+* @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)
+* @returns Array of file metadata objects
+* @throws Will throw an error if the operation fails or client initialization fails
+*
+* @example
+* import { createServerMinioClient, getFilesList } from "@settlemint/sdk-minio";
+*
+* const { client } = createServerMinioClient({
+*   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+*   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+*   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+* });
+*
+* const files = await getFilesList(client, "documents/");
+*/
 async function getFilesList(client, prefix = "", bucket = DEFAULT_BUCKET) {
-  (0, import_runtime2.ensureServer)();
-  console.log(`Listing files with prefix: "${prefix}" in bucket: "${bucket}"`);
-  try {
-    const listOperation = createListObjectsOperation(bucket, prefix);
-    const objects = await executeMinioOperation(client, listOperation);
-    console.log(`Found ${objects.length} files in MinIO`);
-    const fileObjects = await Promise.all(
-      objects.map(async (obj) => {
-        const presignedUrlOperation = createPresignedUrlOperation(
-          bucket,
-          obj.name,
-          3600
-          // 1 hour expiry
-        );
-        const url = await executeMinioOperation(client, presignedUrlOperation);
-        return {
-          id: obj.name,
-          name: obj.name.split("/").pop() || obj.name,
-          contentType: "application/octet-stream",
-          // Default type
-          size: obj.size,
-          uploadedAt: obj.lastModified.toISOString(),
-          etag: obj.etag,
-          url
-        };
-      })
-    );
-    return (0, import_validation2.validate)(FileMetadataSchema.array(), fileObjects);
-  } catch (error) {
-    console.error("Failed to list files:", error);
-    throw new Error(`Failed to list files: ${error instanceof Error ? error.message : String(error)}`);
-  }
+	(0, __settlemint_sdk_utils_runtime.ensureServer)();
+	console.log(`Listing files with prefix: "${prefix}" in bucket: "${bucket}"`);
+	try {
+		const listOperation = createListObjectsOperation(bucket, prefix);
+		const objects = await executeMinioOperation(client, listOperation);
+		console.log(`Found ${objects.length} files in MinIO`);
+		const fileObjects = await Promise.allSettled(objects.map(async (obj) => {
+			try {
+				const presignedUrlOperation = createPresignedUrlOperation(bucket, obj.name, 3600);
+				const url = await executeMinioOperation(client, presignedUrlOperation);
+				return {
+					id: obj.name,
+					name: obj.name.split("/").pop() || obj.name,
+					contentType: "application/octet-stream",
+					size: obj.size,
+					uploadedAt: obj.lastModified.toISOString(),
+					etag: obj.etag,
+					url
+				};
+			} catch (error) {
+				console.warn(`Failed to generate presigned URL for ${obj.name}:`, error);
+				return {
+					id: obj.name,
+					name: obj.name.split("/").pop() || obj.name,
+					contentType: "application/octet-stream",
+					size: obj.size,
+					uploadedAt: obj.lastModified.toISOString(),
+					etag: obj.etag
+				};
+			}
+		})).then((results) => results.filter((result) => result.status === "fulfilled").map((result) => result.value));
+		return (0, __settlemint_sdk_utils_validation.validate)(FileMetadataSchema.array(), fileObjects);
+	} catch (error) {
+		console.error("Failed to list files:", error);
+		throw new Error(`Failed to list files: ${error instanceof Error ? error.message : String(error)}`);
+	}
 }
+/**
+* Gets a single file by its object name
+*
+* @param client - The MinIO client to use
+* @param fileId - The file identifier/path
+* @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)
+* @returns File metadata with presigned URL
+* @throws Will throw an error if the file doesn't exist or client initialization fails
+*
+* @example
+* import { createServerMinioClient, getFileByObjectName } from "@settlemint/sdk-minio";
+*
+* const { client } = createServerMinioClient({
+*   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+*   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+*   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+* });
+*
+* const file = await getFileByObjectName(client, "documents/report.pdf");
+*/
 async function getFileById(client, fileId, bucket = DEFAULT_BUCKET) {
-  (0, import_runtime2.ensureServer)();
-  console.log(`Getting file details for: ${fileId} in bucket: ${bucket}`);
-  try {
-    const statOperation = createStatObjectOperation(bucket, fileId);
-    const statResult = await executeMinioOperation(client, statOperation);
-    const presignedUrlOperation = createPresignedUrlOperation(
-      bucket,
-      fileId,
-      3600
-      // 1 hour expiry
-    );
-    const url = await executeMinioOperation(client, presignedUrlOperation);
-    let size = 0;
-    if (statResult.metaData["content-length"]) {
-      const parsedSize = Number.parseInt(statResult.metaData["content-length"], 10);
-      if (!Number.isNaN(parsedSize)) {
-        size = parsedSize;
-      }
-    } else if (typeof statResult.size === "number" && !Number.isNaN(statResult.size)) {
-      size = statResult.size;
-    }
-    const fileMetadata = {
-      id: fileId,
-      name: fileId.split("/").pop() || fileId,
-      contentType: statResult.metaData["content-type"] || "application/octet-stream",
-      size,
-      uploadedAt: statResult.lastModified.toISOString(),
-      etag: statResult.etag,
-      url
-    };
-    return (0, import_validation2.validate)(FileMetadataSchema, fileMetadata);
-  } catch (error) {
-    console.error(`Failed to get file ${fileId}:`, error);
-    throw new Error(`Failed to get file ${fileId}: ${error instanceof Error ? error.message : String(error)}`);
-  }
+	(0, __settlemint_sdk_utils_runtime.ensureServer)();
+	console.log(`Getting file details for: ${fileId} in bucket: ${bucket}`);
+	try {
+		const statOperation = createStatObjectOperation(bucket, fileId);
+		const statResult = await executeMinioOperation(client, statOperation);
+		const presignedUrlOperation = createPresignedUrlOperation(bucket, fileId, 3600);
+		const url = await executeMinioOperation(client, presignedUrlOperation);
+		let size = 0;
+		if (statResult.metaData["content-length"]) {
+			const parsedSize = Number.parseInt(statResult.metaData["content-length"], 10);
+			if (!Number.isNaN(parsedSize) && parsedSize >= 0 && Number.isFinite(parsedSize)) {
+				size = parsedSize;
+			}
+		} else if (typeof statResult.size === "number" && !Number.isNaN(statResult.size)) {
+			size = statResult.size;
+		}
+		const fileMetadata = {
+			id: fileId,
+			name: fileId.split("/").pop() || fileId,
+			contentType: statResult.metaData["content-type"] || "application/octet-stream",
+			size,
+			uploadedAt: statResult.lastModified.toISOString(),
+			etag: statResult.etag,
+			url
+		};
+		return (0, __settlemint_sdk_utils_validation.validate)(FileMetadataSchema, fileMetadata);
+	} catch (error) {
+		console.error(`Failed to get file ${fileId}:`, error);
+		throw new Error(`Failed to get file ${fileId}: ${error instanceof Error ? error.message : String(error)}`);
+	}
 }
+/**
+* Deletes a file from storage
+*
+* @param client - The MinIO client to use
+* @param fileId - The file identifier/path
+* @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)
+* @returns Success status
+* @throws Will throw an error if deletion fails or client initialization fails
+*
+* @example
+* import { createServerMinioClient, deleteFile } from "@settlemint/sdk-minio";
+*
+* const { client } = createServerMinioClient({
+*   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+*   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+*   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+* });
+*
+* await deleteFile(client, "documents/report.pdf");
+*/
 async function deleteFile(client, fileId, bucket = DEFAULT_BUCKET) {
-  (0, import_runtime2.ensureServer)();
-  try {
-    const deleteOperation = createDeleteOperation(bucket, fileId);
-    await executeMinioOperation(client, deleteOperation);
-    return true;
-  } catch (error) {
-    console.error(`Failed to delete file ${fileId}:`, error);
-    throw new Error(`Failed to delete file ${fileId}: ${error instanceof Error ? error.message : String(error)}`);
-  }
+	(0, __settlemint_sdk_utils_runtime.ensureServer)();
+	try {
+		const deleteOperation = createDeleteOperation(bucket, fileId);
+		await executeMinioOperation(client, deleteOperation);
+		return true;
+	} catch (error) {
+		console.error(`Failed to delete file ${fileId}:`, error);
+		throw new Error(`Failed to delete file ${fileId}: ${error instanceof Error ? error.message : String(error)}`);
+	}
 }
+/**
+* Creates a presigned upload URL for direct browser uploads
+*
+* @param client - The MinIO client to use
+* @param fileName - The file name to use
+* @param path - Optional path/folder
+* @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)
+* @param expirySeconds - How long the URL should be valid for
+* @returns Presigned URL for PUT operation
+* @throws Will throw an error if URL creation fails or client initialization fails
+*
+* @example
+* import { createServerMinioClient, createPresignedUploadUrl } from "@settlemint/sdk-minio";
+*
+* const { client } = createServerMinioClient({
+*   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+*   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+*   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+* });
+*
+* // Generate the presigned URL on the server
+* const url = await createPresignedUploadUrl(client, "report.pdf", "documents/");
+*
+* // Send the URL to the client/browser via HTTP response
+* return Response.json({ uploadUrl: url });
+*
+* // Then in the browser:
+* const response = await fetch('/api/get-upload-url');
+* const { uploadUrl } = await response.json();
+* await fetch(uploadUrl, {
+*  method: 'PUT',
+*  headers: { 'Content-Type': 'application/pdf' },
+*  body: pdfFile
+* });
+*/
 async function createPresignedUploadUrl(client, fileName, path = "", bucket = DEFAULT_BUCKET, expirySeconds = 3600) {
-  (0, import_runtime2.ensureServer)();
-  try {
-    const safeFileName = fileName.replace(/[^a-zA-Z0-9._-]/g, "_");
-    const objectName = normalizePath(path, safeFileName);
-    const presignedPutOperation = createPresignedPutOperation(bucket, objectName, expirySeconds);
-    const url = await executeMinioOperation(client, presignedPutOperation);
-    if (!url) {
-      throw new Error("Failed to generate presigned upload URL");
-    }
-    return url;
-  } catch (error) {
-    console.error("Failed to create presigned upload URL:", error);
-    throw new Error(`Failed to create presigned upload URL: ${error instanceof Error ? error.message : String(error)}`);
-  }
+	(0, __settlemint_sdk_utils_runtime.ensureServer)();
+	try {
+		const safeFileName = fileName.replace(/[^a-zA-Z0-9._-]/g, "_");
+		const objectName = normalizePath(path, safeFileName);
+		const presignedPutOperation = createPresignedPutOperation(bucket, objectName, expirySeconds);
+		const url = await executeMinioOperation(client, presignedPutOperation);
+		if (!url) {
+			throw new Error("Failed to generate presigned upload URL");
+		}
+		return url;
+	} catch (error) {
+		console.error("Failed to create presigned upload URL:", error);
+		throw new Error(`Failed to create presigned upload URL: ${error instanceof Error ? error.message : String(error)}`);
+	}
 }
+/**
+* Uploads a buffer directly to storage
+*
+* @param client - The MinIO client to use
+* @param buffer - The buffer to upload
+* @param objectName - The full object name/path
+* @param contentType - The content type of the file
+* @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)
+* @returns The uploaded file metadata
+* @throws Will throw an error if upload fails or client initialization fails
+*
+* @example
+* import { createServerMinioClient, uploadBuffer } from "@settlemint/sdk-minio";
+*
+* const { client } = createServerMinioClient({
+*   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+*   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+*   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+* });
+*
+* const buffer = Buffer.from("Hello, world!");
+* const uploadedFile = await uploadFile(client, buffer, "documents/hello.txt", "text/plain");
+*/
 async function uploadFile(client, buffer, objectName, contentType, bucket = DEFAULT_BUCKET) {
-  (0, import_runtime2.ensureServer)();
-  try {
-    const metadata = {
-      "content-type": contentType,
-      "upload-time": (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const simpleUploadFn = createSimpleUploadOperation(client);
-    const result = await simpleUploadFn(buffer, bucket, objectName, metadata);
-    const presignedUrlOperation = createPresignedUrlOperation(
-      bucket,
-      objectName,
-      3600
-      // 1 hour expiry
-    );
-    const url = await executeMinioOperation(client, presignedUrlOperation);
-    const fileName = objectName.split("/").pop() || objectName;
-    const fileMetadata = {
-      id: objectName,
-      name: fileName,
-      contentType,
-      size: buffer.length,
-      uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      etag: result.etag,
-      url
-    };
-    return (0, import_validation2.validate)(FileMetadataSchema, fileMetadata);
-  } catch (error) {
-    console.error("Failed to upload file:", error);
-    throw new Error(`Failed to upload file: ${error instanceof Error ? error.message : String(error)}`);
-  }
+	(0, __settlemint_sdk_utils_runtime.ensureServer)();
+	try {
+		const metadata = {
+			"content-type": contentType,
+			"upload-time": new Date().toISOString()
+		};
+		const simpleUploadFn = createSimpleUploadOperation(client);
+		const result = await simpleUploadFn(buffer, bucket, objectName, metadata);
+		const presignedUrlOperation = createPresignedUrlOperation(bucket, objectName, 3600);
+		const url = await executeMinioOperation(client, presignedUrlOperation);
+		const fileName = objectName.split("/").pop() || objectName;
+		const fileMetadata = {
+			id: objectName,
+			name: fileName,
+			contentType,
+			size: buffer.length,
+			uploadedAt: new Date().toISOString(),
+			etag: result.etag,
+			url
+		};
+		return (0, __settlemint_sdk_utils_validation.validate)(FileMetadataSchema, fileMetadata);
+	} catch (error) {
+		console.error("Failed to upload file:", error);
+		throw new Error(`Failed to upload file: ${error instanceof Error ? error.message : String(error)}`);
+	}
 }
 
-// src/minio.ts
+//#endregion
+//#region src/minio.ts
+/**
+* Creates a MinIO client for server-side use with authentication.
+*
+* @param options - The server client options for configuring the MinIO client
+* @returns An object containing the initialized MinIO client
+* @throws Will throw an error if not called on the server or if the options fail validation
+*
+* @example
+* import { createServerMinioClient } from "@settlemint/sdk-minio";
+*
+* const { client } = createServerMinioClient({
+*   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+*   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+*   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+* });
+* client.listBuckets();
+*/
 function createServerMinioClient(options) {
-  (0, import_runtime3.ensureServer)();
-  const validatedOptions = (0, import_validation3.validate)(ServerClientOptionsSchema, options);
-  const url = new URL(validatedOptions.instance);
-  return {
-    client: new import_minio.Client({
-      endPoint: url.hostname,
-      accessKey: validatedOptions.accessKey,
-      secretKey: validatedOptions.secretKey,
-      useSSL: url.protocol !== "http:",
-      port: url.port ? Number(url.port) : void 0,
-      region: "eu-central-1"
-    })
-  };
+	(0, __settlemint_sdk_utils_runtime.ensureServer)();
+	const validatedOptions = (0, __settlemint_sdk_utils_validation.validate)(ServerClientOptionsSchema, options);
+	const url = new URL(validatedOptions.instance);
+	return { client: new minio.Client({
+		endPoint: url.hostname,
+		accessKey: validatedOptions.accessKey,
+		secretKey: validatedOptions.secretKey,
+		useSSL: url.protocol !== "http:",
+		port: url.port ? Number(url.port) : undefined,
+		region: "eu-central-1"
+	}) };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DEFAULT_BUCKET,
-  createPresignedUploadUrl,
-  createServerMinioClient,
-  deleteFile,
-  getFileById,
-  getFilesList,
-  uploadFile
-});
+
+//#endregion
+exports.DEFAULT_BUCKET = DEFAULT_BUCKET;
+exports.createPresignedUploadUrl = createPresignedUploadUrl;
+exports.createServerMinioClient = createServerMinioClient;
+exports.deleteFile = deleteFile;
+exports.getFileById = getFileById;
+exports.getFilesList = getFilesList;
+exports.uploadFile = uploadFile;
 //# sourceMappingURL=minio.cjs.map