@settlemint/sdk-minio 2.3.2-prfd3a56ad → 2.3.3

package/dist/minio.js

@@ -0,0 +1,520 @@
+import { ensureServer } from "@settlemint/sdk-utils/runtime";
+import { UrlSchema, validate } from "@settlemint/sdk-utils/validation";
+import { Client } from "minio";
+import { z } from "zod/v4";
+
+//#region src/helpers/client-options.schema.ts
+/**
+* Schema for validating server client options for the MinIO client.
+*/
+const ServerClientOptionsSchema = z.object({
+	instance: UrlSchema,
+	accessKey: z.string().min(1, "Access key cannot be empty"),
+	secretKey: z.string().min(1, "Secret key cannot be empty")
+});
+
+//#endregion
+//#region src/helpers/schema.ts
+/**
+* Schema for file metadata stored in MinIO.
+* Defines the structure and validation rules for file information.
+*/
+const FileMetadataSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	contentType: z.string(),
+	size: z.number(),
+	uploadedAt: z.string().datetime(),
+	etag: z.string(),
+	url: z.string().url().optional()
+});
+/**
+* Default bucket name to use for file storage when none is specified.
+*/
+const DEFAULT_BUCKET = "uploads";
+
+//#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) {
+	ensureServer();
+	return operation.execute(client);
+}
+
+//#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);
+			});
+		});
+	} };
+}
+/**
+* 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);
+	} };
+}
+/**
+* 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);
+	} };
+}
+/**
+* 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);
+	} };
+}
+/**
+* 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);
+	} };
+}
+/**
+* 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, undefined, metadata);
+	};
+}
+
+//#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}`;
+}
+/**
+* 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) {
+	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 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) {
+	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 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) {
+	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) {
+	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) {
+	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 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)}`);
+	}
+}
+
+//#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) {
+	ensureServer();
+	const validatedOptions = validate(ServerClientOptionsSchema, options);
+	const url = new URL(validatedOptions.instance);
+	return { client: new 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"
+	}) };
+}
+
+//#endregion
+export { DEFAULT_BUCKET, createPresignedUploadUrl, createServerMinioClient, deleteFile, getFileById, getFilesList, uploadFile };
+//# sourceMappingURL=minio.js.map

package/dist/minio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minio.js","names":["client: Client","operation: MinioOperation<T>","bucket: string","client: Client","objects: Array<{\n        name: string;\n        prefix?: string;\n        size: number;\n        etag: string;\n        lastModified: Date;\n      }>","objectName: string","buffer: Buffer","metadata?: ItemBucketMetadata","expirySeconds: number","path: string","fileName: string","client: Client","bucket: string","fileId: string","fileMetadata: FileMetadata","buffer: Buffer","objectName: string","contentType: string","options: ServerClientOptions"],"sources":["../src/helpers/client-options.schema.ts","../src/helpers/schema.ts","../src/helpers/executor.ts","../src/helpers/operations.ts","../src/helpers/functions.ts","../src/minio.ts"],"sourcesContent":["import { UrlSchema } from \"@settlemint/sdk-utils/validation\";\nimport { z } from \"zod/v4\";\n\n/**\n * Schema for validating server client options for the MinIO client.\n */\nexport const ServerClientOptionsSchema = z.object({\n  /** The URL of the MinIO instance to connect to */\n  instance: UrlSchema,\n  /** The MinIO access key used to authenticate with the MinIO server */\n  accessKey: z.string().min(1, \"Access key cannot be empty\"),\n  /** The MinIO secret key used to authenticate with the MinIO server */\n  secretKey: z.string().min(1, \"Secret key cannot be empty\"),\n});\n\n/**\n * Type definition for server client options derived from the ServerClientOptionsSchema.\n */\nexport type ServerClientOptions = z.infer<typeof ServerClientOptionsSchema>;\n","import { z } from \"zod/v4\";\n\n/**\n * Helper type to extract the inferred type from a Zod schema.\n *\n * @template T - The Zod schema type\n */\nexport type Static<T extends z.ZodType> = z.infer<T>;\n\n// ----- Schema Definitions -----\n\n/**\n * Schema for file metadata stored in MinIO.\n * Defines the structure and validation rules for file information.\n */\nexport const FileMetadataSchema = z.object({\n  id: z.string(),\n  name: z.string(),\n  contentType: z.string(),\n  size: z.number(),\n  uploadedAt: z.string().datetime(),\n  etag: z.string(),\n  url: z.string().url().optional(),\n});\n\n/**\n * Type representing file metadata after validation.\n */\nexport interface FileMetadata {\n  /**\n   * The unique identifier for the file.\n   */\n  id: string;\n  /**\n   * The name of the file.\n   */\n  name: string;\n  /**\n   * The content type of the file.\n   */\n  contentType: string;\n\n  /**\n   * The size of the file in bytes.\n   */\n  size: number;\n\n  /**\n   * The date and time the file was uploaded.\n   */\n  uploadedAt: string;\n\n  /**\n   * The ETag of the file.\n   */\n  etag: string;\n\n  /**\n   * The URL of the file.\n   */\n  url?: string;\n}\n\n/**\n * Default bucket name to use for file storage when none is specified.\n */\nexport const DEFAULT_BUCKET = \"uploads\";\n","import { ensureServer } from \"@settlemint/sdk-utils/runtime\";\nimport type { Client } from \"minio\";\nimport type { MinioOperation } from \"./operations.js\";\n\n/**\n * Executes a MinIO operation using the provided client\n *\n * @param client - MinIO client to use\n * @param operation - The operation to execute\n * @returns The result of the operation execution\n * @throws Will throw an error if the operation fails\n *\n * @example\n * import { createServerMinioClient, createListObjectsOperation, executeMinioOperation } from \"@settlemint/sdk-minio\";\n * const { client } = createServerMinioClient({\n *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,\n *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,\n *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!\n * });\n * const listOperation = createListObjectsOperation(\"my-bucket\", \"prefix/\");\n * const result = await executeMinioOperation(client, listOperation);\n */\nexport async function executeMinioOperation<T>(client: Client, operation: MinioOperation<T>): Promise<T> {\n  ensureServer();\n\n  return operation.execute(client);\n}\n","import type { Buffer } from \"node:buffer\";\nimport type { Client, ItemBucketMetadata } from \"minio\";\n\n/**\n * Base interface for all MinIO operations\n *\n * @template T The return type of the operation\n */\nexport interface MinioOperation<T> {\n  execute: (client: Client) => Promise<T>;\n}\n\n/**\n * Creates an operation to list objects in a bucket\n *\n * @param bucket - The bucket name to list objects from\n * @param prefix - Optional prefix to filter objects (like a folder path)\n * @returns A MinioOperation that lists objects when executed\n * @throws Will throw an error if the operation fails\n *\n * @example\n * import { createListObjectsOperation, executeMinioOperation } from \"@settlemint/sdk-minio\";\n *\n * const listOperation = createListObjectsOperation(\"my-bucket\", \"folder/\");\n * const objects = await executeMinioOperation(client, listOperation);\n */\nexport function createListObjectsOperation(\n  bucket: string,\n  prefix = \"\",\n): MinioOperation<\n  Array<{\n    name: string;\n    prefix?: string;\n    size: number;\n    etag: string;\n    lastModified: Date;\n  }>\n> {\n  return {\n    execute: async (client: Client) => {\n      const objectsStream = client.listObjects(bucket, prefix, true);\n      const objects: Array<{\n        name: string;\n        prefix?: string;\n        size: number;\n        etag: string;\n        lastModified: Date;\n      }> = [];\n\n      return new Promise((resolve, reject) => {\n        objectsStream.on(\"data\", (obj) => {\n          // Ensure required properties are not undefined before adding to the array\n          if (obj.name && typeof obj.size === \"number\" && obj.etag && obj.lastModified) {\n            objects.push({\n              name: obj.name,\n              prefix: obj.prefix,\n              size: obj.size,\n              etag: obj.etag,\n              lastModified: obj.lastModified,\n            });\n          }\n        });\n\n        objectsStream.on(\"error\", (err) => {\n          reject(err);\n        });\n\n        objectsStream.on(\"end\", () => {\n          resolve(objects);\n        });\n      });\n    },\n  };\n}\n\n/**\n * Creates an operation to get an object's metadata\n *\n * @param bucket - The bucket name containing the object\n * @param objectName - The object name/path\n * @returns A MinioOperation that gets object stats when executed\n * @throws Will throw an error if the operation fails\n *\n * @example\n * import { createStatObjectOperation, executeMinioOperation } from \"@settlemint/sdk-minio\";\n *\n * const statOperation = createStatObjectOperation(\"my-bucket\", \"folder/file.txt\");\n * const stats = await executeMinioOperation(client, statOperation);\n */\nexport function createStatObjectOperation(\n  bucket: string,\n  objectName: string,\n): MinioOperation<{\n  size: number;\n  etag: string;\n  metaData: Record<string, string>;\n  lastModified: Date;\n}> {\n  return {\n    execute: async (client: Client) => {\n      return client.statObject(bucket, objectName);\n    },\n  };\n}\n\n/**\n * Creates an operation to upload a buffer to MinIO\n *\n * @param bucket - The bucket name to upload to\n * @param objectName - The object name/path to create\n * @param buffer - The buffer containing the file data\n * @param metadata - Optional metadata to attach to the object\n * @returns A MinioOperation that uploads the buffer when executed\n * @throws Will throw an error if the operation fails\n *\n * @example\n * import { createUploadOperation, executeMinioOperation } from \"@settlemint/sdk-minio\";\n *\n * const buffer = Buffer.from(\"file content\");\n * const uploadOperation = createUploadOperation(\"my-bucket\", \"folder/file.txt\", buffer, { \"content-type\": \"text/plain\" });\n * const result = await executeMinioOperation(client, uploadOperation);\n */\nexport function createUploadOperation(\n  bucket: string,\n  objectName: string,\n  buffer: Buffer,\n  metadata?: ItemBucketMetadata,\n): MinioOperation<{ etag: string }> {\n  return {\n    execute: async (client: Client) => {\n      return client.putObject(bucket, objectName, buffer, undefined, metadata);\n    },\n  };\n}\n\n/**\n * Creates an operation to delete an object from MinIO\n *\n * @param bucket - The bucket name containing the object\n * @param objectName - The object name/path to delete\n * @returns A MinioOperation that deletes the object when executed\n * @throws Will throw an error if the operation fails\n *\n * @example\n * import { createDeleteOperation, executeMinioOperation } from \"@settlemint/sdk-minio\";\n *\n * const deleteOperation = createDeleteOperation(\"my-bucket\", \"folder/file.txt\");\n * await executeMinioOperation(client, deleteOperation);\n */\nexport function createDeleteOperation(bucket: string, objectName: string): MinioOperation<void> {\n  return {\n    execute: async (client: Client) => {\n      return client.removeObject(bucket, objectName);\n    },\n  };\n}\n\n/**\n * Creates an operation to generate a presigned URL for an object\n *\n * @param bucket - The bucket name containing the object\n * @param objectName - The object name/path\n * @param expirySeconds - How long the URL should be valid for in seconds\n * @returns A MinioOperation that creates a presigned URL when executed\n * @throws Will throw an error if the operation fails\n *\n * @example\n * import { createPresignedUrlOperation, executeMinioOperation } from \"@settlemint/sdk-minio\";\n *\n * const urlOperation = createPresignedUrlOperation(\"my-bucket\", \"folder/file.txt\", 3600);\n * const url = await executeMinioOperation(client, urlOperation);\n */\nexport function createPresignedUrlOperation(\n  bucket: string,\n  objectName: string,\n  expirySeconds: number,\n): MinioOperation<string> {\n  return {\n    execute: async (client: Client) => {\n      return client.presignedGetObject(bucket, objectName, expirySeconds);\n    },\n  };\n}\n\n/**\n * Creates an operation to generate a presigned PUT URL for direct uploads\n *\n * @param bucket - The bucket name to upload to\n * @param objectName - The object name/path to create\n * @param expirySeconds - How long the URL should be valid for in seconds\n * @returns A MinioOperation that creates a presigned PUT URL when executed\n * @throws Will throw an error if the operation fails\n *\n * @example\n * import { createPresignedPutOperation, executeMinioOperation } from \"@settlemint/sdk-minio\";\n *\n * const putUrlOperation = createPresignedPutOperation(\"my-bucket\", \"folder/file.txt\", 3600);\n * const url = await executeMinioOperation(client, putUrlOperation);\n */\nexport function createPresignedPutOperation(\n  bucket: string,\n  objectName: string,\n  expirySeconds: number,\n): MinioOperation<string> {\n  return {\n    execute: async (client: Client) => {\n      // The MinIO client only accepts the first three parameters for presignedPutObject\n      // Metadata needs to be applied when actually uploading via the presigned URL\n      return client.presignedPutObject(bucket, objectName, expirySeconds);\n    },\n  };\n}\n\n/**\n * Creates a simplified upload function bound to a specific client\n *\n * @param client - The MinIO client to use for uploads\n * @returns A function that uploads buffers to MinIO\n * @throws Will throw an error if the operation fails\n *\n * @example\n * import { createSimpleUploadOperation, getMinioClient } from \"@settlemint/sdk-minio\";\n *\n * const client = await getMinioClient();\n * const uploadFn = createSimpleUploadOperation(client);\n * const result = await uploadFn(buffer, \"my-bucket\", \"folder/file.txt\", { \"content-type\": \"text/plain\" });\n */\nexport function createSimpleUploadOperation(client: Client) {\n  return async (\n    buffer: Buffer,\n    bucket: string,\n    objectName: string,\n    metadata?: ItemBucketMetadata,\n  ): Promise<{ etag: string }> => {\n    return client.putObject(bucket, objectName, buffer, undefined, metadata);\n  };\n}\n","import type { Buffer } from \"node:buffer\";\nimport { ensureServer } from \"@settlemint/sdk-utils/runtime\";\nimport { validate } from \"@settlemint/sdk-utils/validation\";\nimport type { Client } from \"minio\";\nimport { executeMinioOperation } from \"./executor.js\";\nimport {\n  createDeleteOperation,\n  createListObjectsOperation,\n  createPresignedPutOperation,\n  createPresignedUrlOperation,\n  createSimpleUploadOperation,\n  createStatObjectOperation,\n} from \"./operations.js\";\nimport { DEFAULT_BUCKET, FileMetadataSchema } from \"./schema.js\";\nimport type { FileMetadata } from \"./schema.js\";\n\n/**\n * Helper function to normalize paths and prevent double slashes\n *\n * @param path - The path to normalize\n * @param fileName - The filename to append\n * @returns The normalized path with filename\n * @throws Will throw an error if the path is too long (max 1000 characters)\n */\nfunction normalizePath(path: string, fileName: string): string {\n  if (path.length > 1_000) {\n    throw new Error(\"Path is too long\");\n  }\n\n  // Remove trailing slashes from path\n  const cleanPath = path.replace(/\\/+$/, \"\");\n\n  // If path is empty, return just the filename\n  if (!cleanPath) {\n    return fileName;\n  }\n\n  // Join with a single slash\n  return `${cleanPath}/${fileName}`;\n}\n\n/**\n * Gets a list of files with optional prefix filter\n *\n * @param client - The MinIO client to use\n * @param prefix - Optional prefix to filter files (like a folder path)\n * @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)\n * @returns Array of file metadata objects\n * @throws Will throw an error if the operation fails or client initialization fails\n *\n * @example\n * import { createServerMinioClient, getFilesList } from \"@settlemint/sdk-minio\";\n *\n * const { client } = createServerMinioClient({\n *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,\n *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,\n *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!\n * });\n *\n * const files = await getFilesList(client, \"documents/\");\n */\nexport async function getFilesList(\n  client: Client,\n  prefix = \"\",\n  bucket: string = DEFAULT_BUCKET,\n): Promise<FileMetadata[]> {\n  ensureServer();\n  console.log(`Listing files with prefix: \"${prefix}\" in bucket: \"${bucket}\"`);\n\n  try {\n    const listOperation = createListObjectsOperation(bucket, prefix);\n    const objects = await executeMinioOperation(client, listOperation);\n    console.log(`Found ${objects.length} files in MinIO`);\n\n    const fileObjects = await Promise.allSettled(\n      objects.map(async (obj): Promise<FileMetadata> => {\n        try {\n          const presignedUrlOperation = createPresignedUrlOperation(\n            bucket,\n            obj.name,\n            3600, // 1 hour expiry\n          );\n          const url = await executeMinioOperation(client, presignedUrlOperation);\n\n          return {\n            id: obj.name,\n            name: obj.name.split(\"/\").pop() || obj.name,\n            contentType: \"application/octet-stream\", // Default type\n            size: obj.size,\n            uploadedAt: obj.lastModified.toISOString(),\n            etag: obj.etag,\n            url,\n          };\n        } catch (error) {\n          console.warn(`Failed to generate presigned URL for ${obj.name}:`, error);\n          // Return metadata without URL for failed presigned URL operations\n          return {\n            id: obj.name,\n            name: obj.name.split(\"/\").pop() || obj.name,\n            contentType: \"application/octet-stream\", // Default type\n            size: obj.size,\n            uploadedAt: obj.lastModified.toISOString(),\n            etag: obj.etag,\n            // url is omitted for failed operations (undefined)\n          };\n        }\n      }),\n    ).then((results) =>\n      results\n        .filter((result): result is PromiseFulfilledResult<FileMetadata> => result.status === \"fulfilled\")\n        .map((result) => result.value),\n    );\n\n    return validate(FileMetadataSchema.array(), fileObjects);\n  } catch (error) {\n    console.error(\"Failed to list files:\", error);\n    throw new Error(`Failed to list files: ${error instanceof Error ? error.message : String(error)}`);\n  }\n}\n\n/**\n * Gets a single file by its object name\n *\n * @param client - The MinIO client to use\n * @param fileId - The file identifier/path\n * @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)\n * @returns File metadata with presigned URL\n * @throws Will throw an error if the file doesn't exist or client initialization fails\n *\n * @example\n * import { createServerMinioClient, getFileByObjectName } from \"@settlemint/sdk-minio\";\n *\n * const { client } = createServerMinioClient({\n *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,\n *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,\n *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!\n * });\n *\n * const file = await getFileByObjectName(client, \"documents/report.pdf\");\n */\nexport async function getFileById(\n  client: Client,\n  fileId: string,\n  bucket: string = DEFAULT_BUCKET,\n): Promise<FileMetadata> {\n  ensureServer();\n  console.log(`Getting file details for: ${fileId} in bucket: ${bucket}`);\n\n  try {\n    // Get the file metadata\n    const statOperation = createStatObjectOperation(bucket, fileId);\n    const statResult = await executeMinioOperation(client, statOperation);\n\n    // Generate a presigned URL for access\n    const presignedUrlOperation = createPresignedUrlOperation(\n      bucket,\n      fileId,\n      3600, // 1 hour expiry\n    );\n    const url = await executeMinioOperation(client, presignedUrlOperation);\n\n    // Try to get size from metadata first, then from stat result\n    let size = 0;\n\n    // Check for content-length in metadata\n    if (statResult.metaData[\"content-length\"]) {\n      const parsedSize = Number.parseInt(statResult.metaData[\"content-length\"], 10);\n      if (!Number.isNaN(parsedSize) && parsedSize >= 0 && Number.isFinite(parsedSize)) {\n        size = parsedSize;\n      }\n    }\n    // Fallback to statResult.size if available and valid\n    else if (typeof statResult.size === \"number\" && !Number.isNaN(statResult.size)) {\n      size = statResult.size;\n    }\n\n    const fileMetadata: FileMetadata = {\n      id: fileId,\n      name: fileId.split(\"/\").pop() || fileId,\n      contentType: statResult.metaData[\"content-type\"] || \"application/octet-stream\",\n      size,\n      uploadedAt: statResult.lastModified.toISOString(),\n      etag: statResult.etag,\n      url,\n    };\n\n    return validate(FileMetadataSchema, fileMetadata);\n  } catch (error) {\n    console.error(`Failed to get file ${fileId}:`, error);\n    throw new Error(`Failed to get file ${fileId}: ${error instanceof Error ? error.message : String(error)}`);\n  }\n}\n\n/**\n * Deletes a file from storage\n *\n * @param client - The MinIO client to use\n * @param fileId - The file identifier/path\n * @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)\n * @returns Success status\n * @throws Will throw an error if deletion fails or client initialization fails\n *\n * @example\n * import { createServerMinioClient, deleteFile } from \"@settlemint/sdk-minio\";\n *\n * const { client } = createServerMinioClient({\n *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,\n *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,\n *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!\n * });\n *\n * await deleteFile(client, \"documents/report.pdf\");\n */\nexport async function deleteFile(client: Client, fileId: string, bucket: string = DEFAULT_BUCKET): Promise<boolean> {\n  ensureServer();\n  try {\n    const deleteOperation = createDeleteOperation(bucket, fileId);\n    await executeMinioOperation(client, deleteOperation);\n    return true;\n  } catch (error) {\n    console.error(`Failed to delete file ${fileId}:`, error);\n    throw new Error(`Failed to delete file ${fileId}: ${error instanceof Error ? error.message : String(error)}`);\n  }\n}\n\n/**\n * Creates a presigned upload URL for direct browser uploads\n *\n * @param client - The MinIO client to use\n * @param fileName - The file name to use\n * @param path - Optional path/folder\n * @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)\n * @param expirySeconds - How long the URL should be valid for\n * @returns Presigned URL for PUT operation\n * @throws Will throw an error if URL creation fails or client initialization fails\n *\n * @example\n * import { createServerMinioClient, createPresignedUploadUrl } from \"@settlemint/sdk-minio\";\n *\n * const { client } = createServerMinioClient({\n *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,\n *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,\n *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!\n * });\n *\n * // Generate the presigned URL on the server\n * const url = await createPresignedUploadUrl(client, \"report.pdf\", \"documents/\");\n *\n * // Send the URL to the client/browser via HTTP response\n * return Response.json({ uploadUrl: url });\n *\n * // Then in the browser:\n * const response = await fetch('/api/get-upload-url');\n * const { uploadUrl } = await response.json();\n * await fetch(uploadUrl, {\n *  method: 'PUT',\n *  headers: { 'Content-Type': 'application/pdf' },\n *  body: pdfFile\n * });\n */\nexport async function createPresignedUploadUrl(\n  client: Client,\n  fileName: string,\n  path = \"\",\n  bucket: string = DEFAULT_BUCKET,\n  expirySeconds = 3600,\n): Promise<string> {\n  ensureServer();\n  try {\n    const safeFileName = fileName.replace(/[^a-zA-Z0-9._-]/g, \"_\");\n    const objectName = normalizePath(path, safeFileName);\n\n    // Create operation for presigned PUT URL\n    const presignedPutOperation = createPresignedPutOperation(bucket, objectName, expirySeconds);\n\n    const url = await executeMinioOperation(client, presignedPutOperation);\n    if (!url) {\n      throw new Error(\"Failed to generate presigned upload URL\");\n    }\n\n    return url;\n  } catch (error) {\n    console.error(\"Failed to create presigned upload URL:\", error);\n    throw new Error(`Failed to create presigned upload URL: ${error instanceof Error ? error.message : String(error)}`);\n  }\n}\n\n/**\n * Uploads a buffer directly to storage\n *\n * @param client - The MinIO client to use\n * @param buffer - The buffer to upload\n * @param objectName - The full object name/path\n * @param contentType - The content type of the file\n * @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)\n * @returns The uploaded file metadata\n * @throws Will throw an error if upload fails or client initialization fails\n *\n * @example\n * import { createServerMinioClient, uploadBuffer } from \"@settlemint/sdk-minio\";\n *\n * const { client } = createServerMinioClient({\n *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,\n *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,\n *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!\n * });\n *\n * const buffer = Buffer.from(\"Hello, world!\");\n * const uploadedFile = await uploadFile(client, buffer, \"documents/hello.txt\", \"text/plain\");\n */\nexport async function uploadFile(\n  client: Client,\n  buffer: Buffer,\n  objectName: string,\n  contentType: string,\n  bucket: string = DEFAULT_BUCKET,\n): Promise<FileMetadata> {\n  ensureServer();\n  try {\n    // Add file metadata\n    const metadata = {\n      \"content-type\": contentType,\n      \"upload-time\": new Date().toISOString(),\n    };\n\n    // Use the createSimpleUploadOperation\n    const simpleUploadFn = createSimpleUploadOperation(client);\n    const result = await simpleUploadFn(buffer, bucket, objectName, metadata);\n\n    // Generate a presigned URL for immediate access\n    const presignedUrlOperation = createPresignedUrlOperation(\n      bucket,\n      objectName,\n      3600, // 1 hour expiry\n    );\n    const url = await executeMinioOperation(client, presignedUrlOperation);\n\n    const fileName = objectName.split(\"/\").pop() || objectName;\n\n    const fileMetadata: FileMetadata = {\n      id: objectName,\n      name: fileName,\n      contentType,\n      size: buffer.length,\n      uploadedAt: new Date().toISOString(),\n      etag: result.etag,\n      url,\n    };\n\n    return validate(FileMetadataSchema, fileMetadata);\n  } catch (error) {\n    console.error(\"Failed to upload file:\", error);\n    throw new Error(`Failed to upload file: ${error instanceof Error ? error.message : String(error)}`);\n  }\n}\n","import { ensureServer } from \"@settlemint/sdk-utils/runtime\";\nimport { validate } from \"@settlemint/sdk-utils/validation\";\nimport { Client } from \"minio\";\nimport { type ServerClientOptions, ServerClientOptionsSchema } from \"./helpers/client-options.schema.js\";\n\n/**\n * Creates a MinIO client for server-side use with authentication.\n *\n * @param options - The server client options for configuring the MinIO client\n * @returns An object containing the initialized MinIO client\n * @throws Will throw an error if not called on the server or if the options fail validation\n *\n * @example\n * import { createServerMinioClient } from \"@settlemint/sdk-minio\";\n *\n * const { client } = createServerMinioClient({\n *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,\n *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,\n *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!\n * });\n * client.listBuckets();\n */\nexport function createServerMinioClient(options: ServerClientOptions): { client: Client } {\n  ensureServer();\n  const validatedOptions = validate(ServerClientOptionsSchema, options);\n\n  const url = new URL(validatedOptions.instance);\n  return {\n    client: new Client({\n      endPoint: url.hostname,\n      accessKey: validatedOptions.accessKey,\n      secretKey: validatedOptions.secretKey,\n      useSSL: url.protocol !== \"http:\",\n      port: url.port ? Number(url.port) : undefined,\n      region: \"eu-central-1\",\n    }),\n  };\n}\n// Export validation utilities and schemas\nexport {\n  type FileMetadata,\n  DEFAULT_BUCKET,\n} from \"./helpers/schema.js\";\n\n// Export high-level functions\nexport {\n  getFilesList,\n  getFileById,\n  uploadFile,\n  deleteFile,\n  createPresignedUploadUrl,\n} from \"./helpers/functions.js\";\n\n// Re-export required types from minio\nexport type { Client, ItemBucketMetadata } from \"minio\";\n"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@settlemint/sdk-minio",
   "description": "MinIO integration module for SettleMint SDK, providing S3-compatible object storage capabilities",
-  "version": "2.3.2-prfd3a56ad",
+  "version": "2.3.3",
   "type": "module",
   "private": false,
   "license": "FSL-1.1-MIT",
@@ -22,14 +22,14 @@
   },
   "files": ["dist"],
   "main": "./dist/minio.cjs",
-  "module": "./dist/minio.mjs",
+  "module": "./dist/minio.js",
   "types": "./dist/minio.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "import": {
         "types": "./dist/minio.d.ts",
-        "default": "./dist/minio.mjs"
+        "default": "./dist/minio.js"
       },
       "require": {
         "types": "./dist/minio.d.cts",
@@ -38,8 +38,8 @@
     }
   },
   "scripts": {
-    "build": "tsup-node",
-    "dev": "tsup-node --watch",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
     "publint": "publint run --strict",
     "attw": "attw --pack .",
     "test": "bun test",
@@ -51,7 +51,7 @@
   },
   "devDependencies": {},
   "dependencies": {
-    "@settlemint/sdk-utils": "2.3.2-prfd3a56ad",
+    "@settlemint/sdk-utils": "2.3.3",
     "minio": "^8",
     "zod": "^3.25.0"
   },