@wener/common 2.0.2 → 2.0.5

package/lib/fs/minio/createMinioFileSystem.js

@@ -0,0 +1,974 @@
+import { basename, dirname, normalize } from "pathe";
+import { PassThrough, Readable } from "node:stream";
+import { parseS3Url } from "@wener/common/s3";
+import { Client } from "minio";
+export function createMinioFileSystem(options = {}) {
+    const parsed = parseS3Url(options);
+    if (!parsed) {
+        throw new Error('S3 URL or connection options are required');
+    }
+    const { client, prefix } = options;
+    if (!client && (!parsed.endpoint || !parsed.bucket)) {
+        throw new Error('S3 endpoint and bucket are required when client is not provided');
+    }
+    let minioClient;
+    let bucket;
+    if (client) {
+        minioClient = client;
+        bucket = parsed.bucket || '';
+    } else {
+        bucket = parsed.bucket || '';
+        // Import Minio dynamically to avoid requiring it as a dependency
+        minioClient = new Client({
+            endPoint: parsed.endpoint,
+            port: parsed.port,
+            useSSL: parsed.useSsl ?? true,
+            accessKey: parsed.accessKeyId || '',
+            secretKey: parsed.secretAccessKey || '',
+            region: parsed.region,
+            pathStyle: parsed.pathStyle
+        });
+    }
+    // Normalize prefix: remove leading/trailing slashes
+    const normalizedPrefix = prefix ? prefix.replace(/^\/+/, '').replace(/\/+$/, '') : '';
+    return new MinioFS(minioClient, bucket, normalizedPrefix);
+}
+let MinioFS = class MinioFS {
+    client;
+    bucket;
+    prefix;
+    constructor(client, bucket, prefix = ''){
+        this.client = client;
+        this.bucket = bucket;
+        this.prefix = prefix;
+    }
+    /**
+	 * Normalize path to S3 key format (remove leading slash, handle relative paths)
+	 * and prepend the prefix if one is set
+	 */ normalizeKey(path) {
+        if (!path || path === '/') {
+            return this.prefix;
+        }
+        const normalized = normalize(path).replace(/^\/+/, '').replace(/\\/g, '/');
+        // Prepend prefix if set
+        if (this.prefix) {
+            return this.prefix + '/' + normalized;
+        }
+        return normalized;
+    }
+    /**
+	 * Remove prefix from S3 key to get the file system path
+	 */ stripPrefix(key) {
+        if (!key) {
+            return '/';
+        }
+        // If key is just the prefix (or empty after stripping), return root
+        if (this.prefix && key === this.prefix) {
+            return '/';
+        }
+        if (!this.prefix || !key.startsWith(this.prefix + '/')) {
+            return key.startsWith('/') ? key : '/' + key;
+        }
+        const withoutPrefix = key.slice(this.prefix.length);
+        return withoutPrefix || '/';
+    }
+    /**
+	 * Convert S3 key back to file system path (strip prefix and add leading slash)
+	 */ keyToPath(key) {
+        if (!key) {
+            return '/';
+        }
+        return this.stripPrefix(key);
+    }
+    /**
+	 * Get directory path from a key
+	 */ getDirectory(key) {
+        if (!key) {
+            return '/';
+        }
+        const dir = dirname(key).replace(/\\/g, '/');
+        return dir === '.' ? '/' : '/' + dir;
+    }
+    /**
+	 * Check if a key represents a directory (ends with /)
+	 */ isDirectoryKey(key) {
+        return key.endsWith('/');
+    }
+    /**
+	 * Convert MinIO object metadata to IFileStat
+	 */ toFileStat(key, obj) {
+        const isDir = this.isDirectoryKey(key);
+        const path = this.keyToPath(key);
+        const directory = this.getDirectory(key);
+        return {
+            directory,
+            path,
+            name: isDir ? basename(key.slice(0, -1)) || basename(directory) || '/' : basename(key),
+            kind: isDir ? 'directory' : 'file',
+            mtime: obj.lastModified ? new Date(obj.lastModified).getTime() : Date.now(),
+            size: obj.size || 0,
+            meta: {
+                ...obj.etag ? {
+                    etag: obj.etag.replace(/"/g, '')
+                } : {}
+            }
+        };
+    }
+    checkAborted(signal) {
+        if (signal?.aborted) {
+            throw new Error('The operation was aborted');
+        }
+    }
+    async readdir(dir, options = {}) {
+        const { glob, recursive, depth = 1, kind, hidden = true, signal } = options;
+        this.checkAborted(signal);
+        const dirPrefix = this.normalizeKey(dir);
+        const prefixWithSlash = dirPrefix ? dirPrefix.endsWith('/') ? dirPrefix : dirPrefix + '/' : '';
+        try {
+            // MinIO listObjects supports recursive option
+            // When recursive=false, MinIO uses delimiter='/' internally to return CommonPrefixes
+            const objects = [];
+            const commonPrefixes = [];
+            // MinIO listObjects returns a stream
+            // When recursive=false, it returns both objects and prefixes (CommonPrefixes)
+            const objectStream = this.client.listObjects(this.bucket, prefixWithSlash, recursive);
+            await new Promise((resolve, reject)=>{
+                objectStream.on('data', (obj)=>{
+                    if (obj.name) {
+                        objects.push({
+                            name: obj.name,
+                            size: obj.size || 0,
+                            lastModified: obj.lastModified || new Date(),
+                            etag: obj.etag || ''
+                        });
+                    } else if (obj.prefix) {
+                        // CommonPrefixes from MinIO
+                        commonPrefixes.push(obj.prefix);
+                    }
+                });
+                objectStream.on('end', ()=>{
+                    resolve();
+                });
+                objectStream.on('error', (err)=>{
+                    reject(err);
+                });
+                if (signal) {
+                    signal.addEventListener('abort', ()=>{
+                        objectStream.destroy();
+                        reject(new Error('The operation was aborted'));
+                    });
+                }
+            });
+            let results = [];
+            // Process CommonPrefixes (directories) first
+            for (const prefix of commonPrefixes){
+                this.checkAborted(signal);
+                // Skip if not under our prefix
+                if (prefixWithSlash && !prefix.startsWith(prefixWithSlash)) {
+                    continue;
+                }
+                // Get relative path
+                const relativePrefix = prefixWithSlash ? prefix.slice(prefixWithSlash.length) : prefix;
+                const dirName = relativePrefix.replace(/\/$/, ''); // Remove trailing slash
+                if (!dirName) continue;
+                // For non-recursive, only show immediate children
+                if (!recursive && depth === 1) {
+                    const firstSlash = dirName.indexOf('/');
+                    if (firstSlash >= 0) {
+                        continue;
+                    }
+                }
+                const dirKey = prefix.endsWith('/') ? prefix : prefix + '/';
+                const stat = this.toFileStat(dirKey, {
+                    name: dirKey,
+                    size: 0,
+                    lastModified: new Date()
+                });
+                // Filter by hidden
+                if (!hidden && stat.name.startsWith('.')) {
+                    continue;
+                }
+                // Filter by kind
+                if (kind && stat.kind !== kind) {
+                    continue;
+                }
+                results.push(stat);
+            }
+            // Process objects (files) to convert to IFileStat
+            const seenDirs = new Set();
+            for (const obj of objects){
+                this.checkAborted(signal);
+                const key = obj.name;
+                if (!key) continue;
+                // Skip if not under our prefix
+                if (prefixWithSlash && !key.startsWith(prefixWithSlash)) {
+                    continue;
+                }
+                // Strip the prefix from the key for path conversion
+                const relativeKey = prefixWithSlash ? key.slice(prefixWithSlash.length) : key;
+                // Calculate depth: count the number of slashes in the relative path
+                // depth=1 means immediate children (no slashes), depth=2 means one level deep (one slash), etc.
+                const depthLevel = (relativeKey.match(/\//g) || []).length + 1;
+                // Filter by depth
+                if (depthLevel > depth) {
+                    continue;
+                }
+                const isDir = this.isDirectoryKey(key);
+                // Track directories to avoid duplicates
+                if (isDir) {
+                    const dirKey = key.slice(0, -1);
+                    if (seenDirs.has(dirKey)) {
+                        continue;
+                    }
+                    seenDirs.add(dirKey);
+                } else {
+                    // For files in recursive mode, always include them
+                    // For non-recursive mode, check if parent directory was already added
+                    if (!recursive) {
+                        const parentDir = dirname(key).replace(/\\/g, '/') + '/';
+                        if (seenDirs.has(parentDir.slice(0, -1))) {
+                            continue;
+                        }
+                    }
+                }
+                const stat = this.toFileStat(key, {
+                    name: key,
+                    size: obj.size || 0,
+                    lastModified: obj.lastModified,
+                    etag: obj.etag
+                });
+                // Filter by hidden
+                if (!hidden && stat.name.startsWith('.')) {
+                    continue;
+                }
+                // Filter by kind
+                if (kind && stat.kind !== kind) {
+                    continue;
+                }
+                results.push(stat);
+            }
+            // Handle recursive with depth > 1
+            if (!recursive && depth > 1) {
+                const subdirs = results.filter((entry)=>entry.kind === 'directory');
+                for (const subdir of subdirs){
+                    this.checkAborted(signal);
+                    const maxDepth = depth - 1;
+                    if (maxDepth > 0) {
+                        const subEntries = await this.readdir(subdir.path, {
+                            ...options,
+                            depth: maxDepth
+                        });
+                        results = [
+                            ...results,
+                            ...subEntries
+                        ];
+                    }
+                }
+            }
+            // Handle glob filtering
+            if (glob) {
+                const { matcher } = await import("micromatch");
+                const match = matcher(glob);
+                results = results.filter((entry)=>match(entry.path));
+            }
+            return results;
+        } catch (error) {
+            if (error.code === 'NoSuchKey' || error.message?.includes('404') || error.code === 'NotFound') {
+                throw new Error(`Directory not found: ${dir}`);
+            }
+            throw error;
+        }
+    }
+    async stat(entry, options = {}) {
+        const { signal } = options;
+        this.checkAborted(signal);
+        const key = this.normalizeKey(entry);
+        if (!key) {
+            // Root directory
+            return {
+                directory: '/',
+                path: '/',
+                name: '/',
+                kind: 'directory',
+                mtime: Date.now(),
+                size: 0,
+                meta: {}
+            };
+        }
+        try {
+            // Try to get object stat
+            const stat = await this.client.statObject(this.bucket, key);
+            return this.toFileStat(key, {
+                name: key,
+                size: stat.size,
+                lastModified: stat.lastModified,
+                etag: stat.etag
+            });
+        } catch (error) {
+            // If object not found, try checking if it's a directory
+            if (error.code === 'NotFound' || error.code === 'NoSuchKey') {
+                const dirKey = key.endsWith('/') ? key : key + '/';
+                try {
+                    // List objects with this prefix to check if it's a directory
+                    const objectStream = this.client.listObjects(this.bucket, dirKey, false);
+                    let hasObjects = false;
+                    await new Promise((resolve, reject)=>{
+                        objectStream.on('data', ()=>{
+                            hasObjects = true;
+                            objectStream.destroy();
+                            resolve();
+                        });
+                        objectStream.on('end', ()=>{
+                            resolve();
+                        });
+                        objectStream.on('error', reject);
+                        if (signal) {
+                            signal.addEventListener('abort', ()=>{
+                                objectStream.destroy();
+                                reject(new Error('The operation was aborted'));
+                            });
+                        }
+                    });
+                    if (hasObjects) {
+                        // It's a directory
+                        return {
+                            directory: this.getDirectory(key),
+                            path: this.keyToPath(key),
+                            name: basename(key.replace(/\/$/, '')) || '/',
+                            kind: 'directory',
+                            mtime: Date.now(),
+                            size: 0,
+                            meta: {}
+                        };
+                    }
+                } catch  {
+                // Ignore listing errors
+                }
+                throw new Error(`File not found: ${entry}`);
+            }
+            throw error;
+        }
+    }
+    async mkdir(path, options = {}) {
+        const { recursive = false, signal } = options;
+        this.checkAborted(signal);
+        // In S3, directories don't actually exist - they're just prefixes
+        // Optionally create a marker object (empty object with trailing slash)
+        const key = this.normalizeKey(path);
+        if (!key) {
+            return; // Root directory, nothing to do
+        }
+        // Ensure it ends with / to indicate directory
+        const dirKey = key.endsWith('/') ? key : key + '/';
+        // Try to create a marker object (0-byte object)
+        try {
+            const stream = new PassThrough();
+            stream.end();
+            await this.client.putObject(this.bucket, dirKey, stream, 0, {
+                'Content-Type': 'application/x-directory'
+            });
+        } catch (error) {
+            // If it already exists or we don't have permission, that's okay for mkdir
+            if (error.code !== 'NoSuchBucket' && error.code !== 'AccessDenied') {
+            // Ignore other errors for mkdir
+            }
+        }
+    }
+    async readFile(path, options = {}) {
+        const { encoding = 'binary', signal, onDownloadProgress } = options;
+        this.checkAborted(signal);
+        const key = this.normalizeKey(path);
+        if (!key) {
+            throw new Error('Cannot read root directory');
+        }
+        try {
+            // MinIO getObject returns Promise<Readable>
+            const nodeStream = await this.client.getObject(this.bucket, key);
+            const chunks = [];
+            let loaded = 0;
+            let total = 0;
+            // Get object size for progress if available
+            try {
+                const stat = await this.client.statObject(this.bucket, key);
+                total = stat.size;
+            } catch  {
+            // Ignore if stat fails
+            }
+            return new Promise((resolve, reject)=>{
+                nodeStream.on('data', (chunk)=>{
+                    chunks.push(chunk);
+                    loaded += chunk.length;
+                    if (onDownloadProgress) {
+                        onDownloadProgress({
+                            loaded,
+                            total: total || -1
+                        });
+                    }
+                });
+                nodeStream.on('end', ()=>{
+                    const buffer = Buffer.concat(chunks);
+                    if (encoding === 'text') {
+                        resolve(buffer.toString('utf-8'));
+                    } else {
+                        resolve(new Uint8Array(buffer));
+                    }
+                });
+                nodeStream.on('error', reject);
+                if (signal) {
+                    signal.addEventListener('abort', ()=>{
+                        if (nodeStream.destroy) {
+                            nodeStream.destroy(new Error('The operation was aborted'));
+                        }
+                        reject(new Error('The operation was aborted'));
+                    });
+                }
+            });
+        } catch (error) {
+            if (error.code === 'NoSuchKey' || error.code === 'NotFound') {
+                throw new Error(`File not found: ${path}`);
+            }
+            throw error;
+        }
+    }
+    async writeFile(path, data, options = {}) {
+        const { signal, overwrite = true, onUploadProgress } = options;
+        this.checkAborted(signal);
+        const key = this.normalizeKey(path);
+        if (!key) {
+            throw new Error('Cannot write to root directory');
+        }
+        // Check if file exists and overwrite is false
+        if (!overwrite) {
+            const exists = await this.exists(path);
+            if (exists) {
+                throw new Error(`File already exists: ${path}`);
+            }
+        }
+        // Convert data to stream or buffer
+        let stream;
+        let size;
+        if (data instanceof Readable) {
+            stream = data;
+            size = 0; // Unknown size
+        } else if (data instanceof ReadableStream) {
+            // Convert Web ReadableStream to Node Readable
+            stream = Readable.fromWeb(data);
+            size = 0;
+        } else {
+            let buffer;
+            if (data instanceof ArrayBuffer) {
+                buffer = Buffer.from(data);
+            } else if (Buffer.isBuffer(data)) {
+                buffer = data;
+            } else if (typeof data === 'string') {
+                buffer = Buffer.from(data, 'utf-8');
+            } else {
+                // ArrayBufferView
+                buffer = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+            }
+            size = buffer.length;
+            stream = new Readable();
+            stream.push(buffer);
+            stream.push(null);
+        }
+        // Wrap stream for progress tracking if needed
+        if (onUploadProgress) {
+            let loaded = 0;
+            const progressStream = new PassThrough();
+            stream.on('data', (chunk)=>{
+                loaded += chunk.length;
+                onUploadProgress({
+                    loaded,
+                    total: size || -1
+                });
+            });
+            stream.pipe(progressStream);
+            stream = progressStream;
+        }
+        try {
+            await this.client.putObject(this.bucket, key, stream, size);
+        } catch (error) {
+            throw error;
+        }
+    }
+    async rm(path, options = {}) {
+        const { recursive = false, force = false, signal } = options;
+        this.checkAborted(signal);
+        const key = this.normalizeKey(path);
+        if (!key) {
+            throw new Error('Cannot remove root directory');
+        }
+        try {
+            if (recursive) {
+                // List all objects with this prefix
+                const prefix = key.endsWith('/') ? key : key + '/';
+                const objectStream = this.client.listObjects(this.bucket, prefix, true);
+                const keys = [];
+                await new Promise((resolve, reject)=>{
+                    objectStream.on('data', (obj)=>{
+                        if (obj.name) {
+                            keys.push(obj.name);
+                        }
+                    });
+                    objectStream.on('end', ()=>{
+                        resolve();
+                    });
+                    objectStream.on('error', reject);
+                    if (signal) {
+                        signal.addEventListener('abort', ()=>{
+                            objectStream.destroy();
+                            reject(new Error('The operation was aborted'));
+                        });
+                    }
+                });
+                // Delete all objects
+                if (keys.length > 0) {
+                    await this.client.removeObjects(this.bucket, keys);
+                }
+                // Also delete the marker object if it exists
+                const markerKey = prefix;
+                try {
+                    await this.client.removeObject(this.bucket, markerKey);
+                } catch  {
+                // Ignore if marker doesn't exist
+                }
+            } else {
+                // Delete single object
+                try {
+                    await this.client.removeObject(this.bucket, key);
+                } catch (error) {
+                    // Check if it's a directory with files
+                    if (error.code === 'NoSuchKey' || error.code === 'NotFound') {
+                        const prefix = key.endsWith('/') ? key : key + '/';
+                        const objectStream = this.client.listObjects(this.bucket, prefix, false);
+                        let hasObjects = false;
+                        await new Promise((resolve)=>{
+                            objectStream.on('data', ()=>{
+                                hasObjects = true;
+                                objectStream.destroy();
+                                resolve();
+                            });
+                            objectStream.on('end', ()=>{
+                                resolve();
+                            });
+                            objectStream.on('error', ()=>{
+                                resolve();
+                            });
+                        });
+                        if (hasObjects) {
+                            if (!force) {
+                                throw new Error('Directory not empty');
+                            }
+                            // If force, delete recursively
+                            const recursiveStream = this.client.listObjects(this.bucket, prefix, true);
+                            const keys = [];
+                            await new Promise((resolve)=>{
+                                recursiveStream.on('data', (obj)=>{
+                                    if (obj.name) {
+                                        keys.push(obj.name);
+                                    }
+                                });
+                                recursiveStream.on('end', ()=>resolve());
+                                recursiveStream.on('error', ()=>resolve());
+                            });
+                            if (keys.length > 0) {
+                                await this.client.removeObjects(this.bucket, keys);
+                            }
+                            // Also try to remove the marker
+                            try {
+                                await this.client.removeObject(this.bucket, prefix);
+                            } catch  {
+                            // Ignore
+                            }
+                        } else {
+                            // File doesn't exist
+                            if (!force) {
+                                throw new Error('File not found');
+                            }
+                            // If force, just return without error
+                            return;
+                        }
+                    } else if (!force) {
+                        throw error;
+                    }
+                }
+            }
+        } catch (error) {
+            if (force && (error.code === 'NoSuchKey' || error.code === 'NotFound')) {
+                return;
+            }
+            if (force && error.message === 'File not found') {
+                return;
+            }
+            throw error;
+        }
+    }
+    async rename(oldPath, newPath, options = {}) {
+        const { signal, overwrite = false } = options;
+        this.checkAborted(signal);
+        const oldKey = this.normalizeKey(oldPath);
+        const newKey = this.normalizeKey(newPath);
+        if (!oldKey) {
+            throw new Error('Cannot rename root directory');
+        }
+        // Check if target exists and overwrite is false
+        if (!overwrite) {
+            const exists = await this.exists(newPath);
+            if (exists) {
+                throw new Error(`Destination already exists: ${newPath}`);
+            }
+        }
+        try {
+            // Check if it's a directory (has objects with prefix)
+            const isDir = oldKey.endsWith('/');
+            const prefix = isDir ? oldKey : oldKey + '/';
+            const objectStream = this.client.listObjects(this.bucket, prefix, true);
+            const objects = [];
+            await new Promise((resolve, reject)=>{
+                objectStream.on('data', (obj)=>{
+                    if (obj.name) {
+                        objects.push({
+                            name: obj.name
+                        });
+                    }
+                });
+                objectStream.on('end', ()=>{
+                    resolve();
+                });
+                objectStream.on('error', reject);
+                if (signal) {
+                    signal.addEventListener('abort', ()=>{
+                        objectStream.destroy();
+                        reject(new Error('The operation was aborted'));
+                    });
+                }
+            });
+            if (objects.length > 0) {
+                // It's a directory or has multiple objects, move all
+                const newPrefix = newKey.endsWith('/') ? newKey : newKey + '/';
+                // Move all objects
+                await Promise.all(objects.map(async (obj)=>{
+                    const objKey = obj.name;
+                    if (!objKey) return;
+                    const relativeKey = objKey.slice(prefix.length);
+                    const newObjKey = newPrefix + relativeKey;
+                    // Copy then delete
+                    // MinIO copyObject signature: copyObject(bucketName, objectName, sourceObject)
+                    // sourceObject should be a string in format "bucket/object"
+                    await this.client.copyObject(this.bucket, newObjKey, `${this.bucket}/${objKey}`);
+                    await this.client.removeObject(this.bucket, objKey);
+                }));
+                // Move marker object if it exists (skip if it's a directory marker with data)
+                try {
+                    // Check if it's a directory marker (ends with /)
+                    if (prefix.endsWith('/')) {
+                        // Try to copy the marker, but skip if it fails due to "contains data payload"
+                        try {
+                            await this.client.copyObject(this.bucket, newPrefix, `${this.bucket}/${prefix}`);
+                            await this.client.removeObject(this.bucket, prefix);
+                        } catch (error) {
+                            // If error is about data payload, just remove the old marker
+                            // Directory markers are optional in S3
+                            if (error.message?.includes('data payload') || error.code === 'InvalidRequest') {
+                                await this.client.removeObject(this.bucket, prefix);
+                            } else {
+                                throw error;
+                            }
+                        }
+                    } else {
+                        await this.client.copyObject(this.bucket, newPrefix, `${this.bucket}/${prefix}`);
+                        await this.client.removeObject(this.bucket, prefix);
+                    }
+                } catch  {
+                // Ignore if marker doesn't exist
+                }
+            } else {
+                // Single file - copy then delete
+                await this.client.copyObject(this.bucket, newKey, `${this.bucket}/${oldKey}`);
+                await this.client.removeObject(this.bucket, oldKey);
+            }
+        } catch (error) {
+            if (error.code === 'NoSuchKey' || error.code === 'NotFound') {
+                throw new Error(`Source file not found: ${oldPath}`);
+            }
+            throw error;
+        }
+    }
+    async exists(path) {
+        try {
+            const key = this.normalizeKey(path);
+            if (!key) {
+                return true; // Root always exists
+            }
+            await this.client.statObject(this.bucket, key);
+            return true;
+        } catch (error) {
+            if (error.code === 'NotFound' || error.code === 'NoSuchKey') {
+                // Check if it's a directory
+                const key = this.normalizeKey(path);
+                const dirKey = key.endsWith('/') ? key : key + '/';
+                try {
+                    const objectStream = this.client.listObjects(this.bucket, dirKey, false);
+                    let hasObjects = false;
+                    await new Promise((resolve)=>{
+                        objectStream.on('data', ()=>{
+                            hasObjects = true;
+                            objectStream.destroy();
+                            resolve();
+                        });
+                        objectStream.on('end', ()=>{
+                            resolve();
+                        });
+                        objectStream.on('error', ()=>{
+                            resolve();
+                        });
+                    });
+                    return hasObjects;
+                } catch  {
+                    return false;
+                }
+            }
+            return false;
+        }
+    }
+    async copy(src, dest, options = {}) {
+        const { signal, overwrite = true, shallow = false } = options;
+        this.checkAborted(signal);
+        const srcKey = this.normalizeKey(src);
+        const destKey = this.normalizeKey(dest);
+        if (!srcKey) {
+            throw new Error('Cannot copy root directory');
+        }
+        // Check if source exists
+        try {
+            const srcStat = await this.stat(src);
+            // Check if destination exists and overwrite is false
+            if (!overwrite) {
+                const exists = await this.exists(dest);
+                if (exists) {
+                    throw new Error(`Destination already exists: ${dest}`);
+                }
+            }
+            if (srcStat.kind === 'directory') {
+                // Copy directory recursively
+                const srcPrefix = srcKey.endsWith('/') ? srcKey : srcKey + '/';
+                const destPrefix = destKey.endsWith('/') ? destKey : destKey + '/';
+                const objectStream = this.client.listObjects(this.bucket, srcPrefix, !shallow);
+                const objects = [];
+                await new Promise((resolve, reject)=>{
+                    objectStream.on('data', (obj)=>{
+                        if (obj.name) {
+                            objects.push({
+                                name: obj.name
+                            });
+                        }
+                    });
+                    objectStream.on('end', ()=>{
+                        resolve();
+                    });
+                    objectStream.on('error', reject);
+                    if (signal) {
+                        signal.addEventListener('abort', ()=>{
+                            objectStream.destroy();
+                            reject(new Error('The operation was aborted'));
+                        });
+                    }
+                });
+                // Copy all objects
+                await Promise.all(objects.map(async (obj)=>{
+                    const objKey = obj.name;
+                    if (!objKey) return;
+                    const relativeKey = objKey.slice(srcPrefix.length);
+                    const newObjKey = destPrefix + relativeKey;
+                    await this.client.copyObject(this.bucket, newObjKey, `${this.bucket}/${objKey}`);
+                }));
+                // Copy marker object if it exists (skip if it's a directory marker with data)
+                try {
+                    // Check if it's a directory marker (ends with /)
+                    if (srcPrefix.endsWith('/')) {
+                        // Try to copy the marker, but skip if it fails due to "contains data payload"
+                        try {
+                            await this.client.copyObject(this.bucket, destPrefix, `${this.bucket}/${srcPrefix}`);
+                        } catch (error) {
+                            // If error is about data payload, just skip copying the marker
+                            // Directory markers are optional in S3
+                            if (!error.message?.includes('data payload') && error.code !== 'InvalidRequest') {
+                                throw error;
+                            }
+                        }
+                    } else {
+                        await this.client.copyObject(this.bucket, destPrefix, `${this.bucket}/${srcPrefix}`);
+                    }
+                } catch  {
+                // Ignore if marker doesn't exist
+                }
+            } else {
+                // Copy single file
+                await this.client.copyObject(this.bucket, destKey, `${this.bucket}/${srcKey}`);
+            }
+        } catch (error) {
+            if (error.code === 'NoSuchKey' || error.code === 'NotFound') {
+                throw new Error(`Source file not found: ${src}`);
+            }
+            throw error;
+        }
+    }
+    createReadStream(path, options = {}) {
+        const key = this.normalizeKey(path);
+        if (!key) {
+            throw new Error('Cannot read root directory');
+        }
+        const { range, signal } = options;
+        // MinIO getObject and getPartialObject both return Promise<Readable>
+        // Create a Readable stream that waits for the promise to resolve
+        const client = this.client;
+        const bucket = this.bucket;
+        const readable = new Readable({
+            async read () {
+                // Only initialize once
+                if (readable._initialized) {
+                    return;
+                }
+                readable._initialized = true;
+                try {
+                    let nodeStream;
+                    if (range) {
+                        // Use getPartialObject for range requests
+                        // getPartialObject's length parameter: number of bytes to read (not end position)
+                        // So for range {start: 0, end: 4}, we need length = end - start + 1 = 5
+                        const length = range.end !== undefined ? range.end - range.start + 1 : undefined;
+                        nodeStream = await client.getPartialObject(bucket, key, range.start, length);
+                    } else {
+                        nodeStream = await client.getObject(bucket, key);
+                    }
+                    // Pipe the actual stream to our readable
+                    nodeStream.on('data', (chunk)=>{
+                        if (!readable.push(chunk)) {
+                            // If push returns false, the stream is backpressured
+                            nodeStream.pause();
+                        }
+                    });
+                    nodeStream.on('end', ()=>{
+                        readable.push(null);
+                    });
+                    nodeStream.on('error', (err)=>{
+                        readable.emit('error', err);
+                    });
+                    if (signal) {
+                        signal.addEventListener('abort', ()=>{
+                            if (nodeStream.destroy) {
+                                nodeStream.destroy(new Error('The operation was aborted'));
+                            }
+                            readable.emit('error', new Error('The operation was aborted'));
+                        });
+                    }
+                } catch (error) {
+                    readable.emit('error', error);
+                }
+            }
+        });
+        return readable;
+    }
+    createReadableStream(path, options = {}) {
+        const key = this.normalizeKey(path);
+        if (!key) {
+            throw new Error('Cannot read root directory');
+        }
+        const { range, signal } = options;
+        // MinIO getObject and getPartialObject both return Promise<Readable>
+        const client = this.client;
+        const bucket = this.bucket;
+        return new ReadableStream({
+            async start (controller) {
+                try {
+                    let nodeStream;
+                    if (range) {
+                        // Use getPartialObject for range requests
+                        // getPartialObject's length parameter: number of bytes to read (not end position)
+                        // So for range {start: 0, end: 4}, we need length = end - start + 1 = 5
+                        const length = range.end !== undefined ? range.end - range.start + 1 : undefined;
+                        nodeStream = await client.getPartialObject(bucket, key, range.start, length);
+                    } else {
+                        nodeStream = await client.getObject(bucket, key);
+                    }
+                    nodeStream.on('data', (chunk)=>{
+                        controller.enqueue(chunk);
+                    });
+                    nodeStream.on('end', ()=>{
+                        controller.close();
+                    });
+                    nodeStream.on('error', (err)=>{
+                        controller.error(err);
+                    });
+                    if (signal) {
+                        signal.addEventListener('abort', ()=>{
+                            if (nodeStream.destroy) {
+                                nodeStream.destroy(new Error('The operation was aborted'));
+                            }
+                            controller.error(new Error('The operation was aborted'));
+                        });
+                    }
+                } catch (error) {
+                    controller.error(error);
+                }
+            }
+        });
+    }
+    createWriteStream(path, options) {
+        throw new Error('Not implemented');
+    }
+    createWritableStream(path, options = {}) {
+        const key = this.normalizeKey(path);
+        if (!key) {
+            throw new Error('Cannot write to root directory');
+        }
+        const { signal, overwrite = true } = options;
+        this.checkAborted(signal);
+        // Create a WritableStream that buffers data and uploads when done
+        const buffer = [];
+        let controller;
+        const client = this.client;
+        const bucket = this.bucket;
+        const checkAborted = this.checkAborted.bind(this);
+        return new WritableStream({
+            start (ctrl) {
+                controller = ctrl;
+            },
+            async write (chunk) {
+                buffer.push(chunk);
+            },
+            async close () {
+                try {
+                    checkAborted(signal);
+                    const data = Buffer.concat(buffer.map((chunk)=>Buffer.from(chunk)));
+                    const stream = new Readable();
+                    stream.push(data);
+                    stream.push(null);
+                    await client.putObject(bucket, key, stream, data.length);
+                // Controller closes automatically when close() completes successfully
+                } catch (error) {
+                    controller.error(error);
+                }
+            },
+            abort (reason) {
+                buffer.length = 0;
+                controller.error(reason);
+            }
+        });
+    }
+    getUrl(path, options) {
+        if (typeof path === 'object' && path?.kind !== 'file') {
+            return;
+        }
+        const key = typeof path === 'string' ? this.normalizeKey(path) : this.normalizeKey(path.path);
+        if (!key) {
+            return;
+        }
+        // MinIO supports presigned URLs, but getUrl is synchronous
+        // We can't generate presigned URLs synchronously, so return undefined
+        // For presigned URLs, users should use a separate method or await the promise
+        return undefined;
+    }
+};
+
+//# sourceMappingURL=createMinioFileSystem.js.map