@iskra-bun/storage-kit 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# @iskra-bun/storage-kit
+
+## 0.1.0
+
+### Minor Changes
+
+- f9654df: Initial public release. Transport-agnostic file-storage kit extracted from web-kit: `StorageAdapter`/`BaseStorageAdapter`, local and S3/MinIO adapters, and a `createStorageAdapter` factory. Adds `getStream()` to stream files without buffering them entirely in memory.
+
+### Patch Changes
+
+- Fix a path-traversal vulnerability in the local filesystem adapter. `sanitizePath` now strips `..` and `.` segments, and the local adapter resolves every path against the storage root and throws `Path escapes storage root` if the result falls outside it. This is enforced on every `put`/`get`/`getStream`/`delete`/`exists`/`isDirectory` call, so a key like `../secret.txt` can no longer read or delete files outside the configured root.
+- Updated dependencies [f9654df]
+- Updated dependencies
+- Updated dependencies [f9654df]
+    - @iskra-bun/core@0.1.1

package/README.md

@@ -0,0 +1,32 @@
+# @iskra-bun/storage-kit
+
+Almacenamiento de archivos de Iskra con adaptadores intercambiables para local, S3 y MinIO.
+
+## Instalacion
+
+```bash
+bun add @iskra-bun/storage-kit @iskra-bun/core
+```
+
+## Uso rapido
+
+```typescript
+import { createStorageAdapter } from '@iskra-bun/storage-kit';
+
+const storage = await createStorageAdapter({ adapter: 'local', basePath: './uploads' });
+await storage.connect();
+
+await storage.put('docs/readme.txt', Buffer.from('Hello'));
+const bytes = await storage.get('docs/readme.txt');
+const stream = await storage.getStream('docs/readme.txt');
+```
+
+Cambia `adapter: 's3'` o `adapter: 'minio'` para usar almacenamiento de objetos; la API es identica entre adaptadores.
+
+## Documentacion
+
+Guia completa: [docs/storage-kit.md](../../docs/storage-kit.md)
+
+## Licencia
+
+AGPL-3.0-or-later

package/dist/chunk-TNFLKGYU.js

@@ -0,0 +1,245 @@
+// src/base.ts
+var BaseStorageAdapter = class {
+  connected = false;
+  isConnected() {
+    return this.connected;
+  }
+  ensureConnected() {
+    if (!this.connected) {
+      throw new Error("Storage not connected. Call connect() first.");
+    }
+  }
+  async copy(from, to) {
+    const data = await this.get(from);
+    if (!data) {
+      throw new Error(`Source file not found: ${from}`);
+    }
+    await this.put(to, data);
+  }
+  async move(from, to) {
+    await this.copy(from, to);
+    await this.delete(from);
+  }
+  generateFileName(originalName) {
+    const ext = originalName.split(".").pop();
+    const timestamp = Date.now();
+    const random = crypto.randomUUID().replace(/-/g, "");
+    return `${timestamp}-${random}.${ext}`;
+  }
+  sanitizePath(path) {
+    const normalized = path.replace(/\\/g, "/");
+    const segments = normalized.split("/").filter((segment) => segment !== "" && !/^\.+$/.test(segment));
+    return segments.join("/");
+  }
+  getMimeType(filename) {
+    const ext = filename.split(".").pop()?.toLowerCase();
+    const mimeTypes = {
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      png: "image/png",
+      gif: "image/gif",
+      pdf: "application/pdf",
+      txt: "text/plain",
+      json: "application/json",
+      zip: "application/zip"
+    };
+    return mimeTypes[ext || ""] || "application/octet-stream";
+  }
+};
+
+// src/adapters/s3.ts
+import {
+  S3Client,
+  PutObjectCommand,
+  GetObjectCommand,
+  DeleteObjectCommand,
+  HeadObjectCommand,
+  HeadBucketCommand,
+  ListObjectsV2Command,
+  CopyObjectCommand
+} from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+var S3StorageAdapter = class extends BaseStorageAdapter {
+  constructor(config) {
+    super();
+    this.config = config;
+    const conn = config.connection || {};
+    if (conn.endpoint?.startsWith("http://") && conn.useSSL !== false) {
+      throw new Error(
+        "Refusing plaintext S3 endpoint; set useSSL:false to override"
+      );
+    }
+    this.bucket = conn.bucket || "iskra-storage";
+    this.client = new S3Client({
+      endpoint: conn.endpoint,
+      region: conn.region || "us-east-1",
+      credentials: conn.accessKey && conn.secretKey ? { accessKeyId: conn.accessKey, secretAccessKey: conn.secretKey } : void 0,
+      forcePathStyle: !!conn.endpoint
+    });
+  }
+  config;
+  client;
+  bucket;
+  async connect() {
+    try {
+      await this.client.send(new HeadBucketCommand({ Bucket: this.bucket }));
+      this.connected = true;
+    } catch (err) {
+      throw new Error(`Failed to connect to S3 bucket "${this.bucket}": ${err.message}`);
+    }
+  }
+  async disconnect() {
+    this.client.destroy();
+    this.connected = false;
+  }
+  async put(path, data, options) {
+    this.ensureConnected();
+    const key = this.sanitizePath(path);
+    let body;
+    if (data instanceof ReadableStream) {
+      const response = new Response(data);
+      body = new Uint8Array(await response.arrayBuffer());
+    } else {
+      body = data;
+    }
+    await this.client.send(
+      new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+        Body: body,
+        ContentType: options?.contentType || this.getMimeType(key),
+        Metadata: options?.metadata
+      })
+    );
+    return {
+      name: key.split("/").pop() || key,
+      path: key,
+      size: body.length,
+      mimeType: options?.contentType || this.getMimeType(key),
+      lastModified: /* @__PURE__ */ new Date()
+    };
+  }
+  async get(path) {
+    this.ensureConnected();
+    const key = this.sanitizePath(path);
+    try {
+      const response = await this.client.send(
+        new GetObjectCommand({ Bucket: this.bucket, Key: key })
+      );
+      if (!response.Body) return null;
+      return new Uint8Array(await response.Body.transformToByteArray());
+    } catch (err) {
+      if (err.name === "NoSuchKey" || err.$metadata?.httpStatusCode === 404) {
+        return null;
+      }
+      throw err;
+    }
+  }
+  async getStream(path) {
+    this.ensureConnected();
+    const key = this.sanitizePath(path);
+    try {
+      const response = await this.client.send(
+        new GetObjectCommand({ Bucket: this.bucket, Key: key })
+      );
+      if (!response.Body) return null;
+      if (typeof response.Body.transformToWebStream === "function") {
+        return response.Body.transformToWebStream();
+      }
+      const bytes = await response.Body.transformToByteArray();
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue(bytes);
+          controller.close();
+        }
+      });
+    } catch (err) {
+      if (err.name === "NoSuchKey" || err.$metadata?.httpStatusCode === 404) {
+        return null;
+      }
+      throw err;
+    }
+  }
+  async delete(path) {
+    this.ensureConnected();
+    const key = this.sanitizePath(path);
+    await this.client.send(new DeleteObjectCommand({ Bucket: this.bucket, Key: key }));
+  }
+  async exists(path) {
+    this.ensureConnected();
+    const key = this.sanitizePath(path);
+    try {
+      await this.client.send(new HeadObjectCommand({ Bucket: this.bucket, Key: key }));
+      return true;
+    } catch (err) {
+      if (err.name === "NotFound" || err.$metadata?.httpStatusCode === 404) {
+        return false;
+      }
+      throw err;
+    }
+  }
+  async list(prefix) {
+    this.ensureConnected();
+    const files = [];
+    let continuationToken;
+    do {
+      const response = await this.client.send(
+        new ListObjectsV2Command({
+          Bucket: this.bucket,
+          Prefix: prefix ? this.sanitizePath(prefix) : void 0,
+          ContinuationToken: continuationToken
+        })
+      );
+      if (response.Contents) {
+        for (const obj of response.Contents) {
+          if (!obj.Key) continue;
+          files.push({
+            name: obj.Key.split("/").pop() || obj.Key,
+            path: obj.Key,
+            size: obj.Size || 0,
+            mimeType: this.getMimeType(obj.Key),
+            lastModified: obj.LastModified
+          });
+        }
+      }
+      continuationToken = response.IsTruncated ? response.NextContinuationToken : void 0;
+    } while (continuationToken);
+    return files;
+  }
+  async url(path, expiresIn = 3600) {
+    this.ensureConnected();
+    const key = this.sanitizePath(path);
+    const command = new GetObjectCommand({ Bucket: this.bucket, Key: key });
+    return await getSignedUrl(this.client, command, { expiresIn });
+  }
+  async copy(from, to) {
+    this.ensureConnected();
+    const sourceKey = this.sanitizePath(from);
+    const destKey = this.sanitizePath(to);
+    await this.client.send(
+      new CopyObjectCommand({
+        Bucket: this.bucket,
+        CopySource: `${this.bucket}/${sourceKey}`,
+        Key: destKey
+      })
+    );
+  }
+  async isDirectory(path) {
+    this.ensureConnected();
+    const prefix = this.sanitizePath(path).replace(/\/?$/, "/");
+    const response = await this.client.send(
+      new ListObjectsV2Command({
+        Bucket: this.bucket,
+        Prefix: prefix,
+        MaxKeys: 1
+      })
+    );
+    return (response.Contents?.length || 0) > 0;
+  }
+};
+
+export {
+  BaseStorageAdapter,
+  S3StorageAdapter
+};
+//# sourceMappingURL=chunk-TNFLKGYU.js.map

package/dist/chunk-TNFLKGYU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/base.ts","../src/adapters/s3.ts"],"sourcesContent":["export interface StorageConfig {\n    adapter: \"local\" | \"minio\" | \"s3\";\n    basePath?: string;\n    connection?: {\n        endpoint?: string;\n        accessKey?: string;\n        secretKey?: string;\n        bucket?: string;\n        region?: string;\n        useSSL?: boolean;\n    };\n}\n\nexport interface StorageFile {\n    name: string;\n    path: string;\n    size: number;\n    mimeType?: string;\n    lastModified?: Date;\n    url?: string;\n}\n\nexport interface PutOptions {\n    contentType?: string;\n    metadata?: Record<string, string>;\n    public?: boolean;\n}\n\nexport interface StorageAdapter {\n    connect(): Promise<void>;\n    disconnect(): Promise<void>;\n    put(path: string, data: Uint8Array | Buffer | ReadableStream, options?: PutOptions): Promise<StorageFile>;\n    get(path: string): Promise<Uint8Array | null>;\n    getStream(path: string): Promise<ReadableStream | null>;\n    delete(path: string): Promise<void>;\n    exists(path: string): Promise<boolean>;\n    list(prefix?: string): Promise<StorageFile[]>;\n    url(path: string, expiresIn?: number): Promise<string>;\n    copy(from: string, to: string): Promise<void>;\n    move(from: string, to: string): Promise<void>;\n    isDirectory(path: string): Promise<boolean>;\n}\n\nexport abstract class BaseStorageAdapter implements StorageAdapter {\n    protected connected = false;\n\n    abstract connect(): Promise<void>;\n    abstract disconnect(): Promise<void>;\n    abstract put(path: string, data: Uint8Array | Buffer | ReadableStream, options?: PutOptions): Promise<StorageFile>;\n    abstract get(path: string): Promise<Uint8Array | null>;\n    abstract getStream(path: string): Promise<ReadableStream | null>;\n    abstract delete(path: string): Promise<void>;\n    abstract exists(path: string): Promise<boolean>;\n    abstract list(prefix?: string): Promise<StorageFile[]>;\n    abstract url(path: string, expiresIn?: number): Promise<string>;\n    abstract isDirectory(path: string): Promise<boolean>;\n\n    isConnected(): boolean {\n        return this.connected;\n    }\n\n    protected ensureConnected(): void {\n        if (!this.connected) {\n            throw new Error(\"Storage not connected. Call connect() first.\");\n        }\n    }\n\n    async copy(from: string, to: string): Promise<void> {\n        const data = await this.get(from);\n        if (!data) {\n            throw new Error(`Source file not found: ${from}`);\n        }\n        await this.put(to, data);\n    }\n\n    async move(from: string, to: string): Promise<void> {\n        await this.copy(from, to);\n        await this.delete(from);\n    }\n\n    protected generateFileName(originalName: string): string {\n        const ext = originalName.split(\".\").pop();\n        const timestamp = Date.now();\n        const random = crypto.randomUUID().replace(/-/g, \"\");\n        return `${timestamp}-${random}.${ext}`;\n    }\n\n    protected sanitizePath(path: string): string {\n        const normalized = path.replace(/\\\\/g, \"/\");\n        const segments = normalized\n            .split(\"/\")\n            .filter((segment) => segment !== \"\" && !/^\\.+$/.test(segment));\n        return segments.join(\"/\");\n    }\n\n    protected getMimeType(filename: string): string {\n        const ext = filename.split(\".\").pop()?.toLowerCase();\n        const mimeTypes: Record<string, string> = {\n            jpg: \"image/jpeg\",\n            jpeg: \"image/jpeg\",\n            png: \"image/png\",\n            gif: \"image/gif\",\n            pdf: \"application/pdf\",\n            txt: \"text/plain\",\n            json: \"application/json\",\n            zip: \"application/zip\",\n        };\n        return mimeTypes[ext || \"\"] || \"application/octet-stream\";\n    }\n}\n","import { BaseStorageAdapter } from \"../base\";\nimport type { StorageConfig, StorageFile, PutOptions } from \"../base\";\nimport {\n    S3Client,\n    PutObjectCommand,\n    GetObjectCommand,\n    DeleteObjectCommand,\n    HeadObjectCommand,\n    HeadBucketCommand,\n    ListObjectsV2Command,\n    CopyObjectCommand,\n} from \"@aws-sdk/client-s3\";\nimport { getSignedUrl } from \"@aws-sdk/s3-request-presigner\";\n\nexport class S3StorageAdapter extends BaseStorageAdapter {\n    private client: S3Client;\n    private bucket: string;\n\n    constructor(private config: StorageConfig) {\n        super();\n        const conn = config.connection || {};\n\n        if (conn.endpoint?.startsWith(\"http://\") && conn.useSSL !== false) {\n            throw new Error(\n                \"Refusing plaintext S3 endpoint; set useSSL:false to override\"\n            );\n        }\n\n        this.bucket = conn.bucket || \"iskra-storage\";\n\n        this.client = new S3Client({\n            endpoint: conn.endpoint,\n            region: conn.region || \"us-east-1\",\n            credentials:\n                conn.accessKey && conn.secretKey\n                    ? { accessKeyId: conn.accessKey, secretAccessKey: conn.secretKey }\n                    : undefined,\n            forcePathStyle: !!conn.endpoint,\n        });\n    }\n\n    async connect(): Promise<void> {\n        try {\n            await this.client.send(new HeadBucketCommand({ Bucket: this.bucket }));\n            this.connected = true;\n        } catch (err: any) {\n            throw new Error(`Failed to connect to S3 bucket \"${this.bucket}\": ${err.message}`);\n        }\n    }\n\n    async disconnect(): Promise<void> {\n        this.client.destroy();\n        this.connected = false;\n    }\n\n    async put(\n        path: string,\n        data: Uint8Array | Buffer | ReadableStream,\n        options?: PutOptions\n    ): Promise<StorageFile> {\n        this.ensureConnected();\n        const key = this.sanitizePath(path);\n\n        let body: Uint8Array | Buffer;\n        if (data instanceof ReadableStream) {\n            const response = new Response(data);\n            body = new Uint8Array(await response.arrayBuffer());\n        } else {\n            body = data;\n        }\n\n        await this.client.send(\n            new PutObjectCommand({\n                Bucket: this.bucket,\n                Key: key,\n                Body: body,\n                ContentType: options?.contentType || this.getMimeType(key),\n                Metadata: options?.metadata,\n            })\n        );\n\n        return {\n            name: key.split(\"/\").pop() || key,\n            path: key,\n            size: body.length,\n            mimeType: options?.contentType || this.getMimeType(key),\n            lastModified: new Date(),\n        };\n    }\n\n    async get(path: string): Promise<Uint8Array | null> {\n        this.ensureConnected();\n        const key = this.sanitizePath(path);\n\n        try {\n            const response = await this.client.send(\n                new GetObjectCommand({ Bucket: this.bucket, Key: key })\n            );\n\n            if (!response.Body) return null;\n            return new Uint8Array(await response.Body.transformToByteArray());\n        } catch (err: any) {\n            if (err.name === \"NoSuchKey\" || err.$metadata?.httpStatusCode === 404) {\n                return null;\n            }\n            throw err;\n        }\n    }\n\n    async getStream(path: string): Promise<ReadableStream | null> {\n        this.ensureConnected();\n        const key = this.sanitizePath(path);\n\n        try {\n            const response = await this.client.send(\n                new GetObjectCommand({ Bucket: this.bucket, Key: key })\n            );\n\n            if (!response.Body) return null;\n\n            if (typeof (response.Body as any).transformToWebStream === \"function\") {\n                return (response.Body as any).transformToWebStream();\n            }\n\n            // Fallback: buffer then wrap in a ReadableStream\n            const bytes = await response.Body.transformToByteArray();\n            return new ReadableStream({\n                start(controller) {\n                    controller.enqueue(bytes);\n                    controller.close();\n                },\n            });\n        } catch (err: any) {\n            if (err.name === \"NoSuchKey\" || err.$metadata?.httpStatusCode === 404) {\n                return null;\n            }\n            throw err;\n        }\n    }\n\n    async delete(path: string): Promise<void> {\n        this.ensureConnected();\n        const key = this.sanitizePath(path);\n\n        await this.client.send(new DeleteObjectCommand({ Bucket: this.bucket, Key: key }));\n    }\n\n    async exists(path: string): Promise<boolean> {\n        this.ensureConnected();\n        const key = this.sanitizePath(path);\n\n        try {\n            await this.client.send(new HeadObjectCommand({ Bucket: this.bucket, Key: key }));\n            return true;\n        } catch (err: any) {\n            if (err.name === \"NotFound\" || err.$metadata?.httpStatusCode === 404) {\n                return false;\n            }\n            throw err;\n        }\n    }\n\n    async list(prefix?: string): Promise<StorageFile[]> {\n        this.ensureConnected();\n        const files: StorageFile[] = [];\n        let continuationToken: string | undefined;\n\n        do {\n            const response = await this.client.send(\n                new ListObjectsV2Command({\n                    Bucket: this.bucket,\n                    Prefix: prefix ? this.sanitizePath(prefix) : undefined,\n                    ContinuationToken: continuationToken,\n                })\n            );\n\n            if (response.Contents) {\n                for (const obj of response.Contents) {\n                    if (!obj.Key) continue;\n                    files.push({\n                        name: obj.Key.split(\"/\").pop() || obj.Key,\n                        path: obj.Key,\n                        size: obj.Size || 0,\n                        mimeType: this.getMimeType(obj.Key),\n                        lastModified: obj.LastModified,\n                    });\n                }\n            }\n\n            continuationToken = response.IsTruncated ? response.NextContinuationToken : undefined;\n        } while (continuationToken);\n\n        return files;\n    }\n\n    async url(path: string, expiresIn: number = 3600): Promise<string> {\n        this.ensureConnected();\n        const key = this.sanitizePath(path);\n\n        const command = new GetObjectCommand({ Bucket: this.bucket, Key: key });\n        return await getSignedUrl(this.client, command, { expiresIn });\n    }\n\n    async copy(from: string, to: string): Promise<void> {\n        this.ensureConnected();\n        const sourceKey = this.sanitizePath(from);\n        const destKey = this.sanitizePath(to);\n\n        await this.client.send(\n            new CopyObjectCommand({\n                Bucket: this.bucket,\n                CopySource: `${this.bucket}/${sourceKey}`,\n                Key: destKey,\n            })\n        );\n    }\n\n    async isDirectory(path: string): Promise<boolean> {\n        this.ensureConnected();\n        const prefix = this.sanitizePath(path).replace(/\\/?$/, \"/\");\n\n        const response = await this.client.send(\n            new ListObjectsV2Command({\n                Bucket: this.bucket,\n                Prefix: prefix,\n                MaxKeys: 1,\n            })\n        );\n\n        return (response.Contents?.length || 0) > 0;\n    }\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,102 @@
+interface StorageConfig {
+    adapter: "local" | "minio" | "s3";
+    basePath?: string;
+    connection?: {
+        endpoint?: string;
+        accessKey?: string;
+        secretKey?: string;
+        bucket?: string;
+        region?: string;
+        useSSL?: boolean;
+    };
+}
+interface StorageFile {
+    name: string;
+    path: string;
+    size: number;
+    mimeType?: string;
+    lastModified?: Date;
+    url?: string;
+}
+interface PutOptions {
+    contentType?: string;
+    metadata?: Record<string, string>;
+    public?: boolean;
+}
+interface StorageAdapter {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    put(path: string, data: Uint8Array | Buffer | ReadableStream, options?: PutOptions): Promise<StorageFile>;
+    get(path: string): Promise<Uint8Array | null>;
+    getStream(path: string): Promise<ReadableStream | null>;
+    delete(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    list(prefix?: string): Promise<StorageFile[]>;
+    url(path: string, expiresIn?: number): Promise<string>;
+    copy(from: string, to: string): Promise<void>;
+    move(from: string, to: string): Promise<void>;
+    isDirectory(path: string): Promise<boolean>;
+}
+declare abstract class BaseStorageAdapter implements StorageAdapter {
+    protected connected: boolean;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract put(path: string, data: Uint8Array | Buffer | ReadableStream, options?: PutOptions): Promise<StorageFile>;
+    abstract get(path: string): Promise<Uint8Array | null>;
+    abstract getStream(path: string): Promise<ReadableStream | null>;
+    abstract delete(path: string): Promise<void>;
+    abstract exists(path: string): Promise<boolean>;
+    abstract list(prefix?: string): Promise<StorageFile[]>;
+    abstract url(path: string, expiresIn?: number): Promise<string>;
+    abstract isDirectory(path: string): Promise<boolean>;
+    isConnected(): boolean;
+    protected ensureConnected(): void;
+    copy(from: string, to: string): Promise<void>;
+    move(from: string, to: string): Promise<void>;
+    protected generateFileName(originalName: string): string;
+    protected sanitizePath(path: string): string;
+    protected getMimeType(filename: string): string;
+}
+
+declare class LocalStorageAdapter extends BaseStorageAdapter {
+    private basePath;
+    constructor(config: StorageConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    private resolveWithinBase;
+    put(filePath: string, data: Uint8Array | Buffer, options?: PutOptions): Promise<StorageFile>;
+    get(filePath: string): Promise<Uint8Array | null>;
+    getStream(filePath: string): Promise<ReadableStream | null>;
+    delete(filePath: string): Promise<void>;
+    exists(filePath: string): Promise<boolean>;
+    isDirectory(filePath: string): Promise<boolean>;
+    list(prefix?: string): Promise<StorageFile[]>;
+    url(filePath: string, _expiresIn?: number): Promise<string>;
+}
+
+declare class S3StorageAdapter extends BaseStorageAdapter {
+    private config;
+    private client;
+    private bucket;
+    constructor(config: StorageConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    put(path: string, data: Uint8Array | Buffer | ReadableStream, options?: PutOptions): Promise<StorageFile>;
+    get(path: string): Promise<Uint8Array | null>;
+    getStream(path: string): Promise<ReadableStream | null>;
+    delete(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    list(prefix?: string): Promise<StorageFile[]>;
+    url(path: string, expiresIn?: number): Promise<string>;
+    copy(from: string, to: string): Promise<void>;
+    isDirectory(path: string): Promise<boolean>;
+}
+
+/**
+ * Crea e inicializa el adaptador de almacenamiento correcto segun la configuracion.
+ * El adaptador de S3/MinIO se importa de forma lazy para evitar cargar el SDK de AWS
+ * en entornos que solo usan almacenamiento local.
+ */
+declare function createStorageAdapter(config: StorageConfig): Promise<BaseStorageAdapter>;
+
+export { BaseStorageAdapter, LocalStorageAdapter, type PutOptions, S3StorageAdapter, type StorageAdapter, type StorageConfig, type StorageFile, createStorageAdapter };

package/dist/index.js

@@ -0,0 +1,162 @@
+import {
+  BaseStorageAdapter,
+  S3StorageAdapter
+} from "./chunk-TNFLKGYU.js";
+
+// src/adapters/local.ts
+import path from "path";
+import fs from "fs/promises";
+var LocalStorageAdapter = class extends BaseStorageAdapter {
+  basePath;
+  constructor(config) {
+    super();
+    this.basePath = config.basePath || "./storage";
+  }
+  async connect() {
+    await fs.mkdir(this.basePath, { recursive: true });
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+  }
+  resolveWithinBase(filePath) {
+    const sanitizedPath = this.sanitizePath(filePath);
+    const base = path.resolve(this.basePath);
+    const resolved = path.resolve(base, sanitizedPath);
+    if (resolved !== base && !resolved.startsWith(base + path.sep)) {
+      throw new Error(`Path escapes storage root: ${filePath}`);
+    }
+    return resolved;
+  }
+  async put(filePath, data, options) {
+    this.ensureConnected();
+    const sanitizedPath = this.sanitizePath(filePath);
+    const fullPath = this.resolveWithinBase(filePath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, data);
+    const stat = await fs.stat(fullPath);
+    return {
+      name: path.basename(sanitizedPath),
+      path: sanitizedPath,
+      size: stat.size,
+      mimeType: options?.contentType || this.getMimeType(sanitizedPath),
+      lastModified: stat.mtime,
+      url: await this.url(sanitizedPath)
+    };
+  }
+  async get(filePath) {
+    this.ensureConnected();
+    const fullPath = this.resolveWithinBase(filePath);
+    try {
+      return await fs.readFile(fullPath);
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    }
+  }
+  async getStream(filePath) {
+    this.ensureConnected();
+    const fullPath = this.resolveWithinBase(filePath);
+    try {
+      await fs.access(fullPath);
+    } catch {
+      return null;
+    }
+    return Bun.file(fullPath).stream();
+  }
+  async delete(filePath) {
+    this.ensureConnected();
+    const fullPath = this.resolveWithinBase(filePath);
+    try {
+      await fs.unlink(fullPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  async exists(filePath) {
+    this.ensureConnected();
+    let fullPath;
+    try {
+      fullPath = this.resolveWithinBase(filePath);
+    } catch {
+      return false;
+    }
+    try {
+      await fs.access(fullPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async isDirectory(filePath) {
+    this.ensureConnected();
+    let fullPath;
+    try {
+      fullPath = this.resolveWithinBase(filePath);
+    } catch {
+      return false;
+    }
+    try {
+      const stat = await fs.stat(fullPath);
+      return stat.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  async list(prefix) {
+    this.ensureConnected();
+    const searchPath = prefix ? path.join(this.basePath, this.sanitizePath(prefix)) : this.basePath;
+    const files = [];
+    const walk = async (dir) => {
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+          if (entry.isDirectory()) {
+            await walk(fullPath);
+          } else {
+            const relativePath = path.relative(this.basePath, fullPath);
+            const stat = await fs.stat(fullPath);
+            files.push({
+              name: entry.name,
+              path: this.sanitizePath(relativePath),
+              size: stat.size,
+              mimeType: this.getMimeType(entry.name),
+              lastModified: stat.mtime,
+              url: await this.url(this.sanitizePath(relativePath))
+            });
+          }
+        }
+      } catch (e) {
+        if (e.code !== "ENOENT") throw e;
+      }
+    };
+    await walk(searchPath);
+    return files;
+  }
+  async url(filePath, _expiresIn) {
+    const sanitizedPath = this.sanitizePath(filePath);
+    return `/storage/${sanitizedPath}`;
+  }
+};
+
+// src/factory.ts
+async function createStorageAdapter(config) {
+  if (config.adapter === "local") {
+    return new LocalStorageAdapter(config);
+  }
+  if (config.adapter === "s3" || config.adapter === "minio") {
+    const { S3StorageAdapter: S3StorageAdapter2 } = await import("./s3-A3GLE5AG.js");
+    return new S3StorageAdapter2(config);
+  }
+  throw new Error(
+    `Adaptador de almacenamiento no soportado: "${config.adapter}". Usa "local", "s3" o "minio".`
+  );
+}
+export {
+  BaseStorageAdapter,
+  LocalStorageAdapter,
+  S3StorageAdapter,
+  createStorageAdapter
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapters/local.ts","../src/factory.ts"],"sourcesContent":["import { BaseStorageAdapter, type PutOptions, type StorageConfig, type StorageFile } from \"../base\";\nimport path from \"node:path\";\nimport fs from \"node:fs/promises\";\n\nexport class LocalStorageAdapter extends BaseStorageAdapter {\n    private basePath: string;\n\n    constructor(config: StorageConfig) {\n        super();\n        this.basePath = config.basePath || \"./storage\";\n    }\n\n    async connect(): Promise<void> {\n        await fs.mkdir(this.basePath, { recursive: true });\n        this.connected = true;\n    }\n\n    async disconnect(): Promise<void> {\n        this.connected = false;\n    }\n\n    private resolveWithinBase(filePath: string): string {\n        const sanitizedPath = this.sanitizePath(filePath);\n        const base = path.resolve(this.basePath);\n        const resolved = path.resolve(base, sanitizedPath);\n        if (resolved !== base && !resolved.startsWith(base + path.sep)) {\n            throw new Error(`Path escapes storage root: ${filePath}`);\n        }\n        return resolved;\n    }\n\n    async put(filePath: string, data: Uint8Array | Buffer, options?: PutOptions): Promise<StorageFile> {\n        this.ensureConnected();\n\n        const sanitizedPath = this.sanitizePath(filePath);\n        const fullPath = this.resolveWithinBase(filePath);\n\n        await fs.mkdir(path.dirname(fullPath), { recursive: true });\n        await fs.writeFile(fullPath, data);\n\n        const stat = await fs.stat(fullPath);\n\n        return {\n            name: path.basename(sanitizedPath),\n            path: sanitizedPath,\n            size: stat.size,\n            mimeType: options?.contentType || this.getMimeType(sanitizedPath),\n            lastModified: stat.mtime,\n            url: await this.url(sanitizedPath),\n        };\n    }\n\n    async get(filePath: string): Promise<Uint8Array | null> {\n        this.ensureConnected();\n        const fullPath = this.resolveWithinBase(filePath);\n\n        try {\n            return await fs.readFile(fullPath);\n        } catch (error: any) {\n            if (error.code === \"ENOENT\") return null;\n            throw error;\n        }\n    }\n\n    async getStream(filePath: string): Promise<ReadableStream | null> {\n        this.ensureConnected();\n        const fullPath = this.resolveWithinBase(filePath);\n\n        try {\n            await fs.access(fullPath);\n        } catch {\n            return null;\n        }\n\n        return Bun.file(fullPath).stream();\n    }\n\n    async delete(filePath: string): Promise<void> {\n        this.ensureConnected();\n        const fullPath = this.resolveWithinBase(filePath);\n\n        try {\n            await fs.unlink(fullPath);\n        } catch (error: any) {\n            if (error.code !== \"ENOENT\") throw error;\n        }\n    }\n\n    async exists(filePath: string): Promise<boolean> {\n        this.ensureConnected();\n        let fullPath: string;\n        try {\n            fullPath = this.resolveWithinBase(filePath);\n        } catch {\n            return false;\n        }\n        try {\n            await fs.access(fullPath);\n            return true;\n        } catch {\n            return false;\n        }\n    }\n\n    async isDirectory(filePath: string): Promise<boolean> {\n        this.ensureConnected();\n        let fullPath: string;\n        try {\n            fullPath = this.resolveWithinBase(filePath);\n        } catch {\n            return false;\n        }\n        try {\n            const stat = await fs.stat(fullPath);\n            return stat.isDirectory();\n        } catch {\n            return false;\n        }\n    }\n\n    async list(prefix?: string): Promise<StorageFile[]> {\n        this.ensureConnected();\n        const searchPath = prefix\n            ? path.join(this.basePath, this.sanitizePath(prefix))\n            : this.basePath;\n        const files: StorageFile[] = [];\n\n        const walk = async (dir: string): Promise<void> => {\n            try {\n                const entries = await fs.readdir(dir, { withFileTypes: true });\n                for (const entry of entries) {\n                    const fullPath = path.join(dir, entry.name);\n                    if (entry.isDirectory()) {\n                        await walk(fullPath);\n                    } else {\n                        const relativePath = path.relative(this.basePath, fullPath);\n                        const stat = await fs.stat(fullPath);\n                        files.push({\n                            name: entry.name,\n                            path: this.sanitizePath(relativePath),\n                            size: stat.size,\n                            mimeType: this.getMimeType(entry.name),\n                            lastModified: stat.mtime,\n                            url: await this.url(this.sanitizePath(relativePath)),\n                        });\n                    }\n                }\n            } catch (e: any) {\n                if (e.code !== \"ENOENT\") throw e;\n            }\n        };\n\n        await walk(searchPath);\n        return files;\n    }\n\n    async url(filePath: string, _expiresIn?: number): Promise<string> {\n        const sanitizedPath = this.sanitizePath(filePath);\n        return `/storage/${sanitizedPath}`;\n    }\n}\n","import type { StorageConfig } from \"./base\";\nimport { BaseStorageAdapter } from \"./base\";\nimport { LocalStorageAdapter } from \"./adapters/local\";\n\n/**\n * Crea e inicializa el adaptador de almacenamiento correcto segun la configuracion.\n * El adaptador de S3/MinIO se importa de forma lazy para evitar cargar el SDK de AWS\n * en entornos que solo usan almacenamiento local.\n */\nexport async function createStorageAdapter(\n    config: StorageConfig\n): Promise<BaseStorageAdapter> {\n    if (config.adapter === \"local\") {\n        return new LocalStorageAdapter(config);\n    }\n\n    if (config.adapter === \"s3\" || config.adapter === \"minio\") {\n        const { S3StorageAdapter } = await import(\"./adapters/s3\");\n        return new S3StorageAdapter(config);\n    }\n\n    throw new Error(\n        `Adaptador de almacenamiento no soportado: \"${config.adapter}\". Usa \"local\", \"s3\" o \"minio\".`\n    );\n}\n"],"mappings":"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","names":["S3StorageAdapter"]}

package/dist/s3-A3GLE5AG.js

@@ -0,0 +1,7 @@
+import {
+  S3StorageAdapter
+} from "./chunk-TNFLKGYU.js";
+export {
+  S3StorageAdapter
+};
+//# sourceMappingURL=s3-A3GLE5AG.js.map

package/dist/s3-A3GLE5AG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -0,0 +1,57 @@
+{
+    "name": "@iskra-bun/storage-kit",
+    "version": "0.1.0",
+    "description": "Almacenamiento de archivos de Iskra con adaptadores para local, S3 y MinIO.",
+    "keywords": [
+        "iskra",
+        "bun",
+        "storage",
+        "s3",
+        "minio",
+        "files"
+    ],
+    "author": "Joan Lascano",
+    "license": "AGPL-3.0-or-later",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/fearful/iskra.git",
+        "directory": "packages/storage-kit"
+    },
+    "homepage": "https://github.com/fearful/iskra/tree/main/packages/storage-kit#readme",
+    "bugs": "https://github.com/fearful/iskra/issues",
+    "type": "module",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "source": "./src/index.ts",
+            "bun": "./src/index.ts",
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist",
+        "src",
+        "README.md",
+        "CHANGELOG.md"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "test": "bun test",
+        "build": "tsup --config ../../tsup.config.ts"
+    },
+    "dependencies": {
+        "@iskra-bun/core": "0.1.1",
+        "@aws-sdk/client-s3": "^3.600.0",
+        "@aws-sdk/s3-request-presigner": "^3.600.0"
+    },
+    "devDependencies": {
+        "@types/bun": "^1.3.5",
+        "@types/node": "^22.10.2"
+    }
+}

package/src/adapters/local.ts

@@ -0,0 +1,161 @@
+import { BaseStorageAdapter, type PutOptions, type StorageConfig, type StorageFile } from "../base";
+import path from "node:path";
+import fs from "node:fs/promises";
+
+export class LocalStorageAdapter extends BaseStorageAdapter {
+    private basePath: string;
+
+    constructor(config: StorageConfig) {
+        super();
+        this.basePath = config.basePath || "./storage";
+    }
+
+    async connect(): Promise<void> {
+        await fs.mkdir(this.basePath, { recursive: true });
+        this.connected = true;
+    }
+
+    async disconnect(): Promise<void> {
+        this.connected = false;
+    }
+
+    private resolveWithinBase(filePath: string): string {
+        const sanitizedPath = this.sanitizePath(filePath);
+        const base = path.resolve(this.basePath);
+        const resolved = path.resolve(base, sanitizedPath);
+        if (resolved !== base && !resolved.startsWith(base + path.sep)) {
+            throw new Error(`Path escapes storage root: ${filePath}`);
+        }
+        return resolved;
+    }
+
+    async put(filePath: string, data: Uint8Array | Buffer, options?: PutOptions): Promise<StorageFile> {
+        this.ensureConnected();
+
+        const sanitizedPath = this.sanitizePath(filePath);
+        const fullPath = this.resolveWithinBase(filePath);
+
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        await fs.writeFile(fullPath, data);
+
+        const stat = await fs.stat(fullPath);
+
+        return {
+            name: path.basename(sanitizedPath),
+            path: sanitizedPath,
+            size: stat.size,
+            mimeType: options?.contentType || this.getMimeType(sanitizedPath),
+            lastModified: stat.mtime,
+            url: await this.url(sanitizedPath),
+        };
+    }
+
+    async get(filePath: string): Promise<Uint8Array | null> {
+        this.ensureConnected();
+        const fullPath = this.resolveWithinBase(filePath);
+
+        try {
+            return await fs.readFile(fullPath);
+        } catch (error: any) {
+            if (error.code === "ENOENT") return null;
+            throw error;
+        }
+    }
+
+    async getStream(filePath: string): Promise<ReadableStream | null> {
+        this.ensureConnected();
+        const fullPath = this.resolveWithinBase(filePath);
+
+        try {
+            await fs.access(fullPath);
+        } catch {
+            return null;
+        }
+
+        return Bun.file(fullPath).stream();
+    }
+
+    async delete(filePath: string): Promise<void> {
+        this.ensureConnected();
+        const fullPath = this.resolveWithinBase(filePath);
+
+        try {
+            await fs.unlink(fullPath);
+        } catch (error: any) {
+            if (error.code !== "ENOENT") throw error;
+        }
+    }
+
+    async exists(filePath: string): Promise<boolean> {
+        this.ensureConnected();
+        let fullPath: string;
+        try {
+            fullPath = this.resolveWithinBase(filePath);
+        } catch {
+            return false;
+        }
+        try {
+            await fs.access(fullPath);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    async isDirectory(filePath: string): Promise<boolean> {
+        this.ensureConnected();
+        let fullPath: string;
+        try {
+            fullPath = this.resolveWithinBase(filePath);
+        } catch {
+            return false;
+        }
+        try {
+            const stat = await fs.stat(fullPath);
+            return stat.isDirectory();
+        } catch {
+            return false;
+        }
+    }
+
+    async list(prefix?: string): Promise<StorageFile[]> {
+        this.ensureConnected();
+        const searchPath = prefix
+            ? path.join(this.basePath, this.sanitizePath(prefix))
+            : this.basePath;
+        const files: StorageFile[] = [];
+
+        const walk = async (dir: string): Promise<void> => {
+            try {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        await walk(fullPath);
+                    } else {
+                        const relativePath = path.relative(this.basePath, fullPath);
+                        const stat = await fs.stat(fullPath);
+                        files.push({
+                            name: entry.name,
+                            path: this.sanitizePath(relativePath),
+                            size: stat.size,
+                            mimeType: this.getMimeType(entry.name),
+                            lastModified: stat.mtime,
+                            url: await this.url(this.sanitizePath(relativePath)),
+                        });
+                    }
+                }
+            } catch (e: any) {
+                if (e.code !== "ENOENT") throw e;
+            }
+        };
+
+        await walk(searchPath);
+        return files;
+    }
+
+    async url(filePath: string, _expiresIn?: number): Promise<string> {
+        const sanitizedPath = this.sanitizePath(filePath);
+        return `/storage/${sanitizedPath}`;
+    }
+}

package/src/adapters/s3.ts

@@ -0,0 +1,232 @@
+import { BaseStorageAdapter } from "../base";
+import type { StorageConfig, StorageFile, PutOptions } from "../base";
+import {
+    S3Client,
+    PutObjectCommand,
+    GetObjectCommand,
+    DeleteObjectCommand,
+    HeadObjectCommand,
+    HeadBucketCommand,
+    ListObjectsV2Command,
+    CopyObjectCommand,
+} from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+
+export class S3StorageAdapter extends BaseStorageAdapter {
+    private client: S3Client;
+    private bucket: string;
+
+    constructor(private config: StorageConfig) {
+        super();
+        const conn = config.connection || {};
+
+        if (conn.endpoint?.startsWith("http://") && conn.useSSL !== false) {
+            throw new Error(
+                "Refusing plaintext S3 endpoint; set useSSL:false to override"
+            );
+        }
+
+        this.bucket = conn.bucket || "iskra-storage";
+
+        this.client = new S3Client({
+            endpoint: conn.endpoint,
+            region: conn.region || "us-east-1",
+            credentials:
+                conn.accessKey && conn.secretKey
+                    ? { accessKeyId: conn.accessKey, secretAccessKey: conn.secretKey }
+                    : undefined,
+            forcePathStyle: !!conn.endpoint,
+        });
+    }
+
+    async connect(): Promise<void> {
+        try {
+            await this.client.send(new HeadBucketCommand({ Bucket: this.bucket }));
+            this.connected = true;
+        } catch (err: any) {
+            throw new Error(`Failed to connect to S3 bucket "${this.bucket}": ${err.message}`);
+        }
+    }
+
+    async disconnect(): Promise<void> {
+        this.client.destroy();
+        this.connected = false;
+    }
+
+    async put(
+        path: string,
+        data: Uint8Array | Buffer | ReadableStream,
+        options?: PutOptions
+    ): Promise<StorageFile> {
+        this.ensureConnected();
+        const key = this.sanitizePath(path);
+
+        let body: Uint8Array | Buffer;
+        if (data instanceof ReadableStream) {
+            const response = new Response(data);
+            body = new Uint8Array(await response.arrayBuffer());
+        } else {
+            body = data;
+        }
+
+        await this.client.send(
+            new PutObjectCommand({
+                Bucket: this.bucket,
+                Key: key,
+                Body: body,
+                ContentType: options?.contentType || this.getMimeType(key),
+                Metadata: options?.metadata,
+            })
+        );
+
+        return {
+            name: key.split("/").pop() || key,
+            path: key,
+            size: body.length,
+            mimeType: options?.contentType || this.getMimeType(key),
+            lastModified: new Date(),
+        };
+    }
+
+    async get(path: string): Promise<Uint8Array | null> {
+        this.ensureConnected();
+        const key = this.sanitizePath(path);
+
+        try {
+            const response = await this.client.send(
+                new GetObjectCommand({ Bucket: this.bucket, Key: key })
+            );
+
+            if (!response.Body) return null;
+            return new Uint8Array(await response.Body.transformToByteArray());
+        } catch (err: any) {
+            if (err.name === "NoSuchKey" || err.$metadata?.httpStatusCode === 404) {
+                return null;
+            }
+            throw err;
+        }
+    }
+
+    async getStream(path: string): Promise<ReadableStream | null> {
+        this.ensureConnected();
+        const key = this.sanitizePath(path);
+
+        try {
+            const response = await this.client.send(
+                new GetObjectCommand({ Bucket: this.bucket, Key: key })
+            );
+
+            if (!response.Body) return null;
+
+            if (typeof (response.Body as any).transformToWebStream === "function") {
+                return (response.Body as any).transformToWebStream();
+            }
+
+            // Fallback: buffer then wrap in a ReadableStream
+            const bytes = await response.Body.transformToByteArray();
+            return new ReadableStream({
+                start(controller) {
+                    controller.enqueue(bytes);
+                    controller.close();
+                },
+            });
+        } catch (err: any) {
+            if (err.name === "NoSuchKey" || err.$metadata?.httpStatusCode === 404) {
+                return null;
+            }
+            throw err;
+        }
+    }
+
+    async delete(path: string): Promise<void> {
+        this.ensureConnected();
+        const key = this.sanitizePath(path);
+
+        await this.client.send(new DeleteObjectCommand({ Bucket: this.bucket, Key: key }));
+    }
+
+    async exists(path: string): Promise<boolean> {
+        this.ensureConnected();
+        const key = this.sanitizePath(path);
+
+        try {
+            await this.client.send(new HeadObjectCommand({ Bucket: this.bucket, Key: key }));
+            return true;
+        } catch (err: any) {
+            if (err.name === "NotFound" || err.$metadata?.httpStatusCode === 404) {
+                return false;
+            }
+            throw err;
+        }
+    }
+
+    async list(prefix?: string): Promise<StorageFile[]> {
+        this.ensureConnected();
+        const files: StorageFile[] = [];
+        let continuationToken: string | undefined;
+
+        do {
+            const response = await this.client.send(
+                new ListObjectsV2Command({
+                    Bucket: this.bucket,
+                    Prefix: prefix ? this.sanitizePath(prefix) : undefined,
+                    ContinuationToken: continuationToken,
+                })
+            );
+
+            if (response.Contents) {
+                for (const obj of response.Contents) {
+                    if (!obj.Key) continue;
+                    files.push({
+                        name: obj.Key.split("/").pop() || obj.Key,
+                        path: obj.Key,
+                        size: obj.Size || 0,
+                        mimeType: this.getMimeType(obj.Key),
+                        lastModified: obj.LastModified,
+                    });
+                }
+            }
+
+            continuationToken = response.IsTruncated ? response.NextContinuationToken : undefined;
+        } while (continuationToken);
+
+        return files;
+    }
+
+    async url(path: string, expiresIn: number = 3600): Promise<string> {
+        this.ensureConnected();
+        const key = this.sanitizePath(path);
+
+        const command = new GetObjectCommand({ Bucket: this.bucket, Key: key });
+        return await getSignedUrl(this.client, command, { expiresIn });
+    }
+
+    async copy(from: string, to: string): Promise<void> {
+        this.ensureConnected();
+        const sourceKey = this.sanitizePath(from);
+        const destKey = this.sanitizePath(to);
+
+        await this.client.send(
+            new CopyObjectCommand({
+                Bucket: this.bucket,
+                CopySource: `${this.bucket}/${sourceKey}`,
+                Key: destKey,
+            })
+        );
+    }
+
+    async isDirectory(path: string): Promise<boolean> {
+        this.ensureConnected();
+        const prefix = this.sanitizePath(path).replace(/\/?$/, "/");
+
+        const response = await this.client.send(
+            new ListObjectsV2Command({
+                Bucket: this.bucket,
+                Prefix: prefix,
+                MaxKeys: 1,
+            })
+        );
+
+        return (response.Contents?.length || 0) > 0;
+    }
+}

package/src/base.ts

@@ -0,0 +1,110 @@
+export interface StorageConfig {
+    adapter: "local" | "minio" | "s3";
+    basePath?: string;
+    connection?: {
+        endpoint?: string;
+        accessKey?: string;
+        secretKey?: string;
+        bucket?: string;
+        region?: string;
+        useSSL?: boolean;
+    };
+}
+
+export interface StorageFile {
+    name: string;
+    path: string;
+    size: number;
+    mimeType?: string;
+    lastModified?: Date;
+    url?: string;
+}
+
+export interface PutOptions {
+    contentType?: string;
+    metadata?: Record<string, string>;
+    public?: boolean;
+}
+
+export interface StorageAdapter {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    put(path: string, data: Uint8Array | Buffer | ReadableStream, options?: PutOptions): Promise<StorageFile>;
+    get(path: string): Promise<Uint8Array | null>;
+    getStream(path: string): Promise<ReadableStream | null>;
+    delete(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    list(prefix?: string): Promise<StorageFile[]>;
+    url(path: string, expiresIn?: number): Promise<string>;
+    copy(from: string, to: string): Promise<void>;
+    move(from: string, to: string): Promise<void>;
+    isDirectory(path: string): Promise<boolean>;
+}
+
+export abstract class BaseStorageAdapter implements StorageAdapter {
+    protected connected = false;
+
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract put(path: string, data: Uint8Array | Buffer | ReadableStream, options?: PutOptions): Promise<StorageFile>;
+    abstract get(path: string): Promise<Uint8Array | null>;
+    abstract getStream(path: string): Promise<ReadableStream | null>;
+    abstract delete(path: string): Promise<void>;
+    abstract exists(path: string): Promise<boolean>;
+    abstract list(prefix?: string): Promise<StorageFile[]>;
+    abstract url(path: string, expiresIn?: number): Promise<string>;
+    abstract isDirectory(path: string): Promise<boolean>;
+
+    isConnected(): boolean {
+        return this.connected;
+    }
+
+    protected ensureConnected(): void {
+        if (!this.connected) {
+            throw new Error("Storage not connected. Call connect() first.");
+        }
+    }
+
+    async copy(from: string, to: string): Promise<void> {
+        const data = await this.get(from);
+        if (!data) {
+            throw new Error(`Source file not found: ${from}`);
+        }
+        await this.put(to, data);
+    }
+
+    async move(from: string, to: string): Promise<void> {
+        await this.copy(from, to);
+        await this.delete(from);
+    }
+
+    protected generateFileName(originalName: string): string {
+        const ext = originalName.split(".").pop();
+        const timestamp = Date.now();
+        const random = crypto.randomUUID().replace(/-/g, "");
+        return `${timestamp}-${random}.${ext}`;
+    }
+
+    protected sanitizePath(path: string): string {
+        const normalized = path.replace(/\\/g, "/");
+        const segments = normalized
+            .split("/")
+            .filter((segment) => segment !== "" && !/^\.+$/.test(segment));
+        return segments.join("/");
+    }
+
+    protected getMimeType(filename: string): string {
+        const ext = filename.split(".").pop()?.toLowerCase();
+        const mimeTypes: Record<string, string> = {
+            jpg: "image/jpeg",
+            jpeg: "image/jpeg",
+            png: "image/png",
+            gif: "image/gif",
+            pdf: "application/pdf",
+            txt: "text/plain",
+            json: "application/json",
+            zip: "application/zip",
+        };
+        return mimeTypes[ext || ""] || "application/octet-stream";
+    }
+}

package/src/factory.ts

@@ -0,0 +1,25 @@
+import type { StorageConfig } from "./base";
+import { BaseStorageAdapter } from "./base";
+import { LocalStorageAdapter } from "./adapters/local";
+
+/**
+ * Crea e inicializa el adaptador de almacenamiento correcto segun la configuracion.
+ * El adaptador de S3/MinIO se importa de forma lazy para evitar cargar el SDK de AWS
+ * en entornos que solo usan almacenamiento local.
+ */
+export async function createStorageAdapter(
+    config: StorageConfig
+): Promise<BaseStorageAdapter> {
+    if (config.adapter === "local") {
+        return new LocalStorageAdapter(config);
+    }
+
+    if (config.adapter === "s3" || config.adapter === "minio") {
+        const { S3StorageAdapter } = await import("./adapters/s3");
+        return new S3StorageAdapter(config);
+    }
+
+    throw new Error(
+        `Adaptador de almacenamiento no soportado: "${config.adapter}". Usa "local", "s3" o "minio".`
+    );
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export type { StorageConfig, StorageFile, PutOptions, StorageAdapter } from "./base";
+export { BaseStorageAdapter } from "./base";
+export { LocalStorageAdapter } from "./adapters/local";
+export { S3StorageAdapter } from "./adapters/s3";
+export { createStorageAdapter } from "./factory";