@devbro/neko-storage 0.1.3 → 0.1.5

package/dist/index.js

@@ -27,298 +27,686 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AWSS3Storage: () => AWSS3Storage,
-  LocalStorage: () => LocalStorage,
+  AWSS3StorageProvider: () => AWSS3StorageProvider,
+  AzureBlobStorageProvider: () => AzureBlobStorageProvider,
+  FTPStorageProvider: () => FTPStorageProvider,
+  GCPStorageProvider: () => GCPStorageProvider,
+  LocalStorageProvider: () => LocalStorageProvider,
+  SFTPStorageProvider: () => SFTPStorageProvider,
   Storage: () => Storage,
-  StorageFactory: () => StorageFactory
+  StorageProviderFactory: () => StorageProviderFactory
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/Storage.mts
-var _Storage = class _Storage {
-  constructor(config) {
-    this.config = config;
+var Storage = class {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  static {
+    __name(this, "Storage");
   }
-  static canHandle(config) {
-    throw new Error("Method not implemented.");
+  exists(path2) {
+    return this.provider.exists(path2);
+  }
+  put(path2, content) {
+    return this.provider.put(path2, content);
+  }
+  getJson(path2) {
+    return this.provider.getJson(path2);
+  }
+  getString(path2) {
+    return this.provider.getString(path2);
+  }
+  getBuffer(path2) {
+    return this.provider.getBuffer(path2);
+  }
+  getStream(path2) {
+    return this.provider.getStream(path2);
+  }
+  delete(path2) {
+    return this.provider.delete(path2);
+  }
+  metadata(path2) {
+    return this.provider.metadata(path2);
   }
 };
-__name(_Storage, "Storage");
-var Storage = _Storage;
 
-// src/AWSS3Storage.mts
+// src/providers/AWSS3StorageProvider.mts
 var import_client_s3 = require("@aws-sdk/client-s3");
 var import_stream = __toESM(require("stream"), 1);
-var _AWSS3Storage = class _AWSS3Storage extends Storage {
+var AWSS3StorageProvider = class {
   constructor(config) {
-    var _a;
-    super(config);
     this.config = config;
-    if (!_AWSS3Storage.canHandle(config)) {
-      throw new Error(`storage engine cannot handle this config.`);
-    }
-    this.s3 = new import_client_s3.S3Client(((_a = this.config) == null ? void 0 : _a.s3Config) || {});
+    this.s3 = new import_client_s3.S3Client(this.config);
   }
-  static canHandle(config) {
-    return config.engine === "s3";
+  static {
+    __name(this, "AWSS3StorageProvider");
   }
-  exists(path2) {
-    return __async(this, null, function* () {
-      var _a;
-      try {
-        yield this.s3.send(new import_client_s3.HeadObjectCommand({ Bucket: (_a = this.config) == null ? void 0 : _a.bucket, Key: path2 }));
-        return true;
-      } catch (error) {
-        if (error.name === "NotFound") {
-          return false;
-        }
-        throw error;
-      }
-    });
-  }
-  put(path2, content) {
-    return __async(this, null, function* () {
-      let body;
-      if (typeof content === "string" || content instanceof Buffer) {
-        body = content;
-      } else if (typeof content === "object" && !(content instanceof import_stream.default)) {
-        body = JSON.stringify(content);
-      } else if (content instanceof import_stream.default) {
-        body = content;
-      } else {
-        throw new Error("Unsupported content type");
-      }
-      yield this.s3.send(
-        new import_client_s3.PutObjectCommand({
-          Bucket: this.config.bucket,
-          Key: path2,
-          Body: body
-        })
-      );
+  s3;
+  async exists(path2) {
+    try {
+      await this.s3.send(new import_client_s3.HeadObjectCommand({ Bucket: this.config.bucket, Key: path2 }));
       return true;
-    });
+    } catch (error) {
+      if (error.name === "NotFound") {
+        return false;
+      }
+      throw error;
+    }
   }
-  getJson(path2) {
-    return __async(this, null, function* () {
-      const data = yield this.s3.send(
-        new import_client_s3.GetObjectCommand({ Bucket: this.config.bucket, Key: path2 })
-      );
-      const body = yield this.streamToString(data.Body);
-      return JSON.parse(body);
-    });
+  async put(path2, content) {
+    let body;
+    if (typeof content === "string" || content instanceof Buffer) {
+      body = content;
+    } else if (typeof content === "object" && !(content instanceof import_stream.default)) {
+      body = JSON.stringify(content);
+    } else if (content instanceof import_stream.default) {
+      body = content;
+    } else {
+      throw new Error("Unsupported content type");
+    }
+    await this.s3.send(
+      new import_client_s3.PutObjectCommand({
+        Bucket: this.config.bucket,
+        Key: path2,
+        Body: body
+      })
+    );
+    return true;
   }
-  getString(path2) {
-    return __async(this, null, function* () {
-      const data = yield this.s3.send(
-        new import_client_s3.GetObjectCommand({ Bucket: this.config.bucket, Key: path2 })
-      );
-      return yield this.streamToString(data.Body);
-    });
+  async getJson(path2) {
+    const data = await this.s3.send(
+      new import_client_s3.GetObjectCommand({ Bucket: this.config.bucket, Key: path2 })
+    );
+    const body = await this.streamToString(data.Body);
+    return JSON.parse(body);
   }
-  delete(path2) {
-    return __async(this, null, function* () {
-      yield this.s3.send(new import_client_s3.DeleteObjectCommand({ Bucket: this.config.bucket, Key: path2 }));
-      return true;
-    });
+  async getString(path2) {
+    const data = await this.s3.send(
+      new import_client_s3.GetObjectCommand({ Bucket: this.config.bucket, Key: path2 })
+    );
+    return await this.streamToString(data.Body);
   }
-  streamToString(stream) {
-    return __async(this, null, function* () {
-      return new Promise((resolve, reject) => {
-        const chunks = [];
-        stream.on("data", (chunk) => chunks.push(chunk));
-        stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
-        stream.on("error", reject);
-      });
-    });
+  async delete(path2) {
+    await this.s3.send(new import_client_s3.DeleteObjectCommand({ Bucket: this.config.bucket, Key: path2 }));
+    return true;
   }
-  getBuffer(path2) {
-    return __async(this, null, function* () {
-      const data = yield this.s3.send(
-        new import_client_s3.GetObjectCommand({ Bucket: this.config.bucket, Key: path2 })
-      );
+  async streamToString(stream) {
+    return new Promise((resolve, reject) => {
       const chunks = [];
-      const stream = data.Body;
-      return new Promise((resolve, reject) => {
-        stream.on("data", (chunk) => chunks.push(chunk));
-        stream.on("end", () => resolve(Buffer.concat(chunks)));
-        stream.on("error", reject);
-      });
+      stream.on("data", (chunk) => chunks.push(chunk));
+      stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+      stream.on("error", reject);
     });
   }
-  getStream(path2) {
-    return __async(this, null, function* () {
-      const data = yield this.s3.send(
-        new import_client_s3.GetObjectCommand({ Bucket: this.config.bucket, Key: path2 })
-      );
-      return data.Body;
+  async getBuffer(path2) {
+    const data = await this.s3.send(
+      new import_client_s3.GetObjectCommand({ Bucket: this.config.bucket, Key: path2 })
+    );
+    const chunks = [];
+    const stream = data.Body;
+    return new Promise((resolve, reject) => {
+      stream.on("data", (chunk) => chunks.push(chunk));
+      stream.on("end", () => resolve(Buffer.concat(chunks)));
+      stream.on("error", reject);
     });
   }
-  metadata(path2) {
-    return __async(this, null, function* () {
-      const metadata = yield this.s3.send(
-        new import_client_s3.HeadObjectCommand({ Bucket: this.config.bucket, Key: path2 })
-      );
-      return {
-        size: metadata.ContentLength || 0,
-        mimeType: metadata.ContentType || "unknown",
-        lastModifiedDate: (metadata.LastModified || /* @__PURE__ */ new Date(0)).toISOString()
-      };
-    });
+  async getStream(path2) {
+    const data = await this.s3.send(
+      new import_client_s3.GetObjectCommand({ Bucket: this.config.bucket, Key: path2 })
+    );
+    return data.Body;
+  }
+  async metadata(path2) {
+    const metadata = await this.s3.send(
+      new import_client_s3.HeadObjectCommand({ Bucket: this.config.bucket, Key: path2 })
+    );
+    return {
+      size: metadata.ContentLength || 0,
+      mimeType: metadata.ContentType || "unknown",
+      lastModifiedDate: (metadata.LastModified || /* @__PURE__ */ new Date(0)).toISOString()
+    };
   }
 };
-__name(_AWSS3Storage, "AWSS3Storage");
-var AWSS3Storage = _AWSS3Storage;
 
-// src/LocalStorage.mts
+// src/providers/LocalStorageProvider.mts
 var import_stream2 = __toESM(require("stream"), 1);
 var fs = __toESM(require("fs/promises"), 1);
 var import_fs = require("fs");
 var path = __toESM(require("path"), 1);
 var mime = __toESM(require("mime-types"), 1);
-var _LocalStorage = class _LocalStorage extends Storage {
+var LocalStorageProvider = class {
   constructor(config) {
-    super(config);
-    if (!_LocalStorage.canHandle(config)) {
-      throw new Error(`storage engine cannot handle this config.`);
-    }
+    this.config = config;
     fs.mkdir(this.config.basePath, { recursive: true }).catch((error) => {
       throw error;
     });
   }
-  metadata(path2) {
-    return __async(this, null, function* () {
-      const fullPath = this.getFullPath(path2);
-      const stats = yield fs.stat(fullPath);
-      return {
-        size: stats.size,
-        mimeType: mime.lookup(fullPath) || "unknown",
-        lastModifiedDate: stats.mtime.toISOString()
-      };
-    });
+  static {
+    __name(this, "LocalStorageProvider");
   }
-  static canHandle(config) {
-    if (config.engine === "local") {
-      return true;
-    }
-    return false;
+  async metadata(path2) {
+    const fullPath = this.getFullPath(path2);
+    const stats = await fs.stat(fullPath);
+    return {
+      size: stats.size,
+      mimeType: mime.lookup(fullPath) || "unknown",
+      lastModifiedDate: stats.mtime.toISOString()
+    };
   }
   getFullPath(filePath) {
     return path.join(this.config.basePath, filePath);
   }
-  exists(path2) {
-    return __async(this, null, function* () {
-      try {
-        yield fs.access(this.getFullPath(path2));
-        return true;
-      } catch (e) {
-        return false;
-      }
+  async exists(path2) {
+    try {
+      await fs.access(this.getFullPath(path2));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async put(filepath, content) {
+    const fullPath = this.getFullPath(filepath);
+    const dir = path.dirname(fullPath);
+    await fs.mkdir(dir, { recursive: true });
+    if (typeof content === "string" || content instanceof Buffer) {
+      await fs.writeFile(fullPath, content);
+    } else if (typeof content === "object" && !(content instanceof import_stream2.default)) {
+      await fs.writeFile(fullPath, JSON.stringify(content, null, 2));
+    } else if (typeof content === "object" && content instanceof import_stream2.default) {
+      const writeStream = (0, import_fs.createWriteStream)(fullPath);
+      await new Promise((resolve, reject) => {
+        content.pipe(writeStream);
+        content.on("end", resolve);
+        content.on("error", reject);
+      });
+    } else {
+      throw new Error("Unsupported content type");
+    }
+    return true;
+  }
+  async getJson(path2) {
+    const fullPath = this.getFullPath(path2);
+    const content = await fs.readFile(fullPath, "utf-8");
+    return JSON.parse(content);
+  }
+  async getString(path2, encoding = "utf-8") {
+    const fullPath = this.getFullPath(path2);
+    return await fs.readFile(fullPath, encoding);
+  }
+  async getBuffer(path2) {
+    const fullPath = this.getFullPath(path2);
+    return await fs.readFile(fullPath);
+  }
+  async getStream(path2) {
+    const fullPath = this.getFullPath(path2);
+    return (0, import_fs.createReadStream)(fullPath);
+  }
+  async delete(path2) {
+    const fullPath = this.getFullPath(path2);
+    await fs.unlink(fullPath);
+    return true;
+  }
+};
+
+// src/providers/GCPStorageProvider.mts
+var import_storage = require("@google-cloud/storage");
+var import_stream3 = __toESM(require("stream"), 1);
+var mime2 = __toESM(require("mime-types"), 1);
+var GCPStorageProvider = class {
+  constructor(config) {
+    this.config = config;
+    const { bucket, ...gcpOptions } = config;
+    this.storage = new import_storage.Storage(gcpOptions);
+  }
+  static {
+    __name(this, "GCPStorageProvider");
+  }
+  storage;
+  async exists(path2) {
+    try {
+      const file = this.storage.bucket(this.config.bucket).file(path2);
+      const [exists] = await file.exists();
+      return exists;
+    } catch (error) {
+      return false;
+    }
+  }
+  async put(path2, content) {
+    const file = this.storage.bucket(this.config.bucket).file(path2);
+    let data;
+    if (typeof content === "string" || content instanceof Buffer) {
+      data = content;
+    } else if (typeof content === "object" && !(content instanceof import_stream3.default)) {
+      data = JSON.stringify(content);
+    } else if (content instanceof import_stream3.default) {
+      data = content;
+    } else {
+      throw new Error("Unsupported content type");
+    }
+    if (data instanceof import_stream3.default) {
+      await new Promise((resolve, reject) => {
+        data.pipe(file.createWriteStream()).on("finish", () => resolve()).on("error", reject);
+      });
+    } else {
+      await file.save(data);
+    }
+    return true;
+  }
+  async getJson(path2) {
+    const data = await this.getString(path2);
+    return JSON.parse(data);
+  }
+  async getString(path2) {
+    const file = this.storage.bucket(this.config.bucket).file(path2);
+    const [content] = await file.download();
+    return content.toString("utf-8");
+  }
+  async getBuffer(path2) {
+    const file = this.storage.bucket(this.config.bucket).file(path2);
+    const [content] = await file.download();
+    return content;
+  }
+  async getStream(path2) {
+    const file = this.storage.bucket(this.config.bucket).file(path2);
+    return file.createReadStream();
+  }
+  async delete(path2) {
+    const file = this.storage.bucket(this.config.bucket).file(path2);
+    await file.delete();
+    return true;
+  }
+  async metadata(path2) {
+    const file = this.storage.bucket(this.config.bucket).file(path2);
+    const [metadata] = await file.getMetadata();
+    return {
+      size: typeof metadata.size === "number" ? metadata.size : parseInt(metadata.size || "0", 10),
+      mimeType: metadata.contentType || mime2.lookup(path2) || "unknown",
+      lastModifiedDate: metadata.updated || (/* @__PURE__ */ new Date(0)).toISOString()
+    };
+  }
+};
+
+// src/providers/AzureBlobStorageProvider.mts
+var import_storage_blob = require("@azure/storage-blob");
+var import_stream4 = __toESM(require("stream"), 1);
+var mime3 = __toESM(require("mime-types"), 1);
+var AzureBlobStorageProvider = class {
+  constructor(config) {
+    this.config = config;
+    const { accountName, accountKey, sasToken } = config;
+    if (accountKey) {
+      const sharedKeyCredential = new import_storage_blob.StorageSharedKeyCredential(accountName, accountKey);
+      this.blobServiceClient = new import_storage_blob.BlobServiceClient(
+        `https://${accountName}.blob.core.windows.net`,
+        sharedKeyCredential
+      );
+    } else if (sasToken) {
+      this.blobServiceClient = new import_storage_blob.BlobServiceClient(
+        `https://${accountName}.blob.core.windows.net?${sasToken}`
+      );
+    } else {
+      throw new Error("Either accountKey or sasToken is required for Azure Blob Storage");
+    }
+  }
+  static {
+    __name(this, "AzureBlobStorageProvider");
+  }
+  blobServiceClient;
+  async exists(path2) {
+    try {
+      const containerClient = this.blobServiceClient.getContainerClient(this.config.containerName);
+      const blobClient = containerClient.getBlobClient(path2);
+      return await blobClient.exists();
+    } catch (error) {
+      return false;
+    }
+  }
+  async put(path2, content) {
+    const containerClient = this.blobServiceClient.getContainerClient(this.config.containerName);
+    const blockBlobClient = containerClient.getBlockBlobClient(path2);
+    let data;
+    if (typeof content === "string" || content instanceof Buffer) {
+      data = content;
+    } else if (typeof content === "object" && !(content instanceof import_stream4.default)) {
+      data = JSON.stringify(content);
+    } else if (content instanceof import_stream4.default) {
+      data = content;
+    } else {
+      throw new Error("Unsupported content type");
+    }
+    if (data instanceof import_stream4.default) {
+      await blockBlobClient.uploadStream(data);
+    } else {
+      const buffer = typeof data === "string" ? Buffer.from(data) : data;
+      await blockBlobClient.upload(buffer, buffer.length);
+    }
+    return true;
+  }
+  async getJson(path2) {
+    const data = await this.getString(path2);
+    return JSON.parse(data);
+  }
+  async getString(path2) {
+    const buffer = await this.getBuffer(path2);
+    return buffer.toString("utf-8");
+  }
+  async getBuffer(path2) {
+    const containerClient = this.blobServiceClient.getContainerClient(this.config.containerName);
+    const blobClient = containerClient.getBlobClient(path2);
+    const downloadResponse = await blobClient.download();
+    if (!downloadResponse.readableStreamBody) {
+      throw new Error("Failed to download blob");
+    }
+    return await this.streamToBuffer(downloadResponse.readableStreamBody);
+  }
+  async getStream(path2) {
+    const containerClient = this.blobServiceClient.getContainerClient(this.config.containerName);
+    const blobClient = containerClient.getBlobClient(path2);
+    const downloadResponse = await blobClient.download();
+    if (!downloadResponse.readableStreamBody) {
+      throw new Error("Failed to download blob");
+    }
+    return downloadResponse.readableStreamBody;
+  }
+  async delete(path2) {
+    const containerClient = this.blobServiceClient.getContainerClient(this.config.containerName);
+    const blobClient = containerClient.getBlobClient(path2);
+    await blobClient.delete();
+    return true;
+  }
+  async metadata(path2) {
+    const containerClient = this.blobServiceClient.getContainerClient(this.config.containerName);
+    const blobClient = containerClient.getBlobClient(path2);
+    const properties = await blobClient.getProperties();
+    return {
+      size: properties.contentLength || 0,
+      mimeType: properties.contentType || mime3.lookup(path2) || "unknown",
+      lastModifiedDate: properties.lastModified?.toISOString() || (/* @__PURE__ */ new Date(0)).toISOString()
+    };
+  }
+  async streamToBuffer(readableStream) {
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      readableStream.on("data", (chunk) => {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      });
+      readableStream.on("end", () => {
+        resolve(Buffer.concat(chunks));
+      });
+      readableStream.on("error", reject);
     });
   }
-  put(filepath, content) {
-    return __async(this, null, function* () {
-      const fullPath = this.getFullPath(filepath);
-      const dir = path.dirname(fullPath);
-      yield fs.mkdir(dir, { recursive: true });
+};
+
+// src/providers/FTPStorageProvider.mts
+var import_basic_ftp = require("basic-ftp");
+var import_stream5 = __toESM(require("stream"), 1);
+var mime4 = __toESM(require("mime-types"), 1);
+var FTPStorageProvider = class {
+  constructor(config) {
+    this.config = config;
+  }
+  static {
+    __name(this, "FTPStorageProvider");
+  }
+  async getClient() {
+    const client = new import_basic_ftp.Client();
+    await client.access({
+      host: this.config.host,
+      port: this.config.port || 21,
+      user: this.config.user || "anonymous",
+      password: this.config.password || "",
+      secure: this.config.secure || false
+    });
+    return client;
+  }
+  async exists(path2) {
+    const client = await this.getClient();
+    try {
+      await client.size(path2);
+      return true;
+    } catch (error) {
+      return false;
+    } finally {
+      client.close();
+    }
+  }
+  async put(path2, content) {
+    const client = await this.getClient();
+    try {
+      let stream;
       if (typeof content === "string" || content instanceof Buffer) {
-        yield fs.writeFile(fullPath, content);
-      } else if (typeof content === "object" && !(content instanceof import_stream2.default)) {
-        yield fs.writeFile(fullPath, JSON.stringify(content, null, 2));
-      } else if (typeof content === "object" && content instanceof import_stream2.default) {
-        const writeStream = (0, import_fs.createWriteStream)(fullPath);
-        yield new Promise((resolve, reject) => {
-          content.pipe(writeStream);
-          content.on("end", resolve);
-          content.on("error", reject);
-        });
+        const readable = new import_stream5.Readable();
+        readable.push(typeof content === "string" ? Buffer.from(content) : content);
+        readable.push(null);
+        stream = readable;
+      } else if (typeof content === "object" && !(content instanceof import_stream5.default)) {
+        const readable = new import_stream5.Readable();
+        readable.push(Buffer.from(JSON.stringify(content)));
+        readable.push(null);
+        stream = readable;
+      } else if (content instanceof import_stream5.default) {
+        stream = content;
       } else {
         throw new Error("Unsupported content type");
       }
+      await client.uploadFrom(stream, path2);
       return true;
-    });
+    } finally {
+      client.close();
+    }
   }
-  getJson(path2) {
-    return __async(this, null, function* () {
-      const fullPath = this.getFullPath(path2);
-      const content = yield fs.readFile(fullPath, "utf-8");
-      return JSON.parse(content);
-    });
+  async getJson(path2) {
+    const data = await this.getString(path2);
+    return JSON.parse(data);
   }
-  getString(path2, encoding = "utf-8") {
-    return __async(this, null, function* () {
-      const fullPath = this.getFullPath(path2);
-      return yield fs.readFile(fullPath, encoding);
-    });
+  async getString(path2) {
+    const buffer = await this.getBuffer(path2);
+    return buffer.toString("utf-8");
   }
-  getBuffer(path2) {
-    return __async(this, null, function* () {
-      const fullPath = this.getFullPath(path2);
-      return yield fs.readFile(fullPath);
-    });
+  async getBuffer(path2) {
+    const client = await this.getClient();
+    try {
+      const chunks = [];
+      const writable = new import_stream5.PassThrough();
+      writable.on("data", (chunk) => {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      });
+      await client.downloadTo(writable, path2);
+      return Buffer.concat(chunks);
+    } finally {
+      client.close();
+    }
   }
-  getStream(path2) {
-    return __async(this, null, function* () {
-      const fullPath = this.getFullPath(path2);
-      return (0, import_fs.createReadStream)(fullPath);
+  async getStream(path2) {
+    const client = await this.getClient();
+    const passThrough = new import_stream5.PassThrough();
+    client.downloadTo(passThrough, path2).then(() => client.close()).catch((error) => {
+      client.close();
+      passThrough.destroy(error);
     });
+    passThrough.on("close", () => {
+      try {
+        client.close();
+      } catch {
+      }
+    });
+    return passThrough;
   }
-  delete(path2) {
-    return __async(this, null, function* () {
-      const fullPath = this.getFullPath(path2);
-      yield fs.unlink(fullPath);
+  async delete(path2) {
+    const client = await this.getClient();
+    try {
+      await client.remove(path2);
       return true;
-    });
+    } finally {
+      client.close();
+    }
+  }
+  async metadata(path2) {
+    const client = await this.getClient();
+    try {
+      const size = await client.size(path2);
+      const lastMod = await client.lastMod(path2);
+      return {
+        size,
+        mimeType: mime4.lookup(path2) || "unknown",
+        lastModifiedDate: lastMod?.toISOString() || (/* @__PURE__ */ new Date(0)).toISOString()
+      };
+    } finally {
+      client.close();
+    }
   }
 };
-__name(_LocalStorage, "LocalStorage");
-var LocalStorage = _LocalStorage;
 
-// src/StorageFactory.mts
-var _StorageFactory = class _StorageFactory {
-  registerStorageEngine(engine) {
-    _StorageFactory.storageEngines.push(engine);
-  }
-  static create(config) {
-    for (const engine of _StorageFactory.storageEngines) {
-      if (engine.canHandle(config)) {
-        return new engine(config);
+// src/providers/SFTPStorageProvider.mts
+var import_ssh2_sftp_client = __toESM(require("ssh2-sftp-client"), 1);
+var import_stream6 = __toESM(require("stream"), 1);
+var mime5 = __toESM(require("mime-types"), 1);
+var SFTPStorageProvider = class {
+  constructor(config) {
+    this.config = config;
+  }
+  static {
+    __name(this, "SFTPStorageProvider");
+  }
+  async getClient() {
+    const client = new import_ssh2_sftp_client.default();
+    await client.connect({
+      host: this.config.host,
+      port: this.config.port || 22,
+      username: this.config.username,
+      password: this.config.password,
+      privateKey: this.config.privateKey,
+      passphrase: this.config.passphrase
+    });
+    return client;
+  }
+  async exists(path2) {
+    const client = await this.getClient();
+    try {
+      const result = await client.exists(path2);
+      return result !== false;
+    } catch (error) {
+      return false;
+    } finally {
+      await client.end();
+    }
+  }
+  async put(path2, content) {
+    const client = await this.getClient();
+    try {
+      let data;
+      if (typeof content === "string") {
+        data = content;
+      } else if (content instanceof Buffer) {
+        data = content;
+      } else if (typeof content === "object" && !(content instanceof import_stream6.default)) {
+        data = Buffer.from(JSON.stringify(content));
+      } else if (content instanceof import_stream6.default) {
+        data = content;
+      } else {
+        throw new Error("Unsupported content type");
       }
+      await client.put(data, path2);
+      return true;
+    } finally {
+      await client.end();
+    }
+  }
+  async getJson(path2) {
+    const data = await this.getString(path2);
+    return JSON.parse(data);
+  }
+  async getString(path2) {
+    const buffer = await this.getBuffer(path2);
+    return buffer.toString("utf-8");
+  }
+  async getBuffer(path2) {
+    const client = await this.getClient();
+    try {
+      const buffer = await client.get(path2);
+      return buffer;
+    } finally {
+      await client.end();
     }
-    throw new Error("No matchin storage engine found");
+  }
+  async getStream(path2) {
+    const client = await this.getClient();
+    const passThrough = new import_stream6.PassThrough();
+    client.get(path2).then((data) => {
+      if (data instanceof Buffer) {
+        const readable = new import_stream6.Readable();
+        readable.push(data);
+        readable.push(null);
+        readable.pipe(passThrough);
+      } else if (data instanceof import_stream6.default) {
+        data.pipe(passThrough);
+      }
+      return client.end();
+    }).catch((error) => {
+      client.end().catch(() => {
+      });
+      passThrough.destroy(error);
+    });
+    passThrough.on("close", () => {
+      client.end().catch(() => {
+      });
+    });
+    return passThrough;
+  }
+  async delete(path2) {
+    const client = await this.getClient();
+    try {
+      await client.delete(path2);
+      return true;
+    } finally {
+      await client.end();
+    }
+  }
+  async metadata(path2) {
+    const client = await this.getClient();
+    try {
+      const stats = await client.stat(path2);
+      return {
+        size: stats.size || 0,
+        mimeType: mime5.lookup(path2) || "unknown",
+        lastModifiedDate: new Date((stats.modifyTime || 0) * 1e3).toISOString()
+      };
+    } finally {
+      await client.end();
+    }
+  }
+};
+
+// src/StorageProviderFactory.mts
+var import_neko_helper = require("@devbro/neko-helper");
+var StorageProviderFactory = class _StorageProviderFactory {
+  static {
+    __name(this, "StorageProviderFactory");
+  }
+  static instance = new import_neko_helper.FlexibleFactory();
+  static register(key, factory) {
+    _StorageProviderFactory.instance.register(key, factory);
+  }
+  static create(key, ...args) {
+    return _StorageProviderFactory.instance.create(key, ...args);
   }
 };
-__name(_StorageFactory, "StorageFactory");
-_StorageFactory.storageEngines = [LocalStorage, AWSS3Storage];
-var StorageFactory = _StorageFactory;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AWSS3Storage,
-  LocalStorage,
+  AWSS3StorageProvider,
+  AzureBlobStorageProvider,
+  FTPStorageProvider,
+  GCPStorageProvider,
+  LocalStorageProvider,
+  SFTPStorageProvider,
   Storage,
-  StorageFactory
+  StorageProviderFactory
 });
 //# sourceMappingURL=index.js.map