@devbro/neko-storage 0.1.4 → 0.1.6

package/README.md

@@ -39,22 +39,119 @@ let is_file_deleted = await storage.delete('path/to/file/filename.ext');
 
 ## available drivers
 
-local
+### Local Storage
+
+Store files on the local file system.
 
 ```ts
-import { Storage, StorageFactory } from '@devbro/neko-storage';
+import { LocalStorageProvider, Storage } from '@devbro/neko-storage';
 
 const basePath = path.resolve(os.tmpdir(), `test-storage-${randomUUID()}`);
-const storage: Storage = StorageFactory.create({ engine: 'local', basePath });
+const provider = new LocalStorageProvider({ engine: 'local', basePath });
+const storage = new Storage(provider);
 ```
 
-AWS S3
+### AWS S3
+
+Store files in Amazon S3 buckets.
 
 ```ts
-import { Storage, StorageFactory } from '@devbro/neko-storage';
+import { AWSS3StorageProvider, Storage } from '@devbro/neko-storage';
+
+const provider = new AWSS3StorageProvider({
+  engine: 's3',
+  bucket: 'your-bucket-name',
+  s3Config: {
+    region: 'us-east-1',
+    credentials: {
+      accessKeyId: 'YOUR_ACCESS_KEY',
+      secretAccessKey: 'YOUR_SECRET_KEY',
+    },
+  },
+});
+const storage = new Storage(provider);
+```
+
+### Google Cloud Storage (GCP)
+
+Store files in Google Cloud Storage buckets.
+
+```ts
+import { GCPStorageProvider, Storage } from '@devbro/neko-storage';
+
+const provider = new GCPStorageProvider({
+  engine: 'gcp',
+  bucket: 'your-bucket-name',
+  gcpConfig: {
+    projectId: 'your-project-id',
+    keyFilename: '/path/to/service-account-key.json',
+    // Or use credentials object directly
+    // credentials: {...}
+  },
+});
+const storage = new Storage(provider);
+```
+
+### Azure Blob Storage
+
+Store files in Azure Blob Storage containers.
 
-const s3Config : AWSS3Config = ???;
-const storage: Storage = StorageFactory.create({ engine: 's3', { s3Config } });
+```ts
+import { AzureBlobStorageProvider, Storage } from '@devbro/neko-storage';
+
+const provider = new AzureBlobStorageProvider({
+  engine: 'azure',
+  azureConfig: {
+    accountName: 'your-storage-account',
+    accountKey: 'YOUR_ACCOUNT_KEY', // Or use sasToken instead
+    containerName: 'your-container-name',
+  },
+});
+const storage = new Storage(provider);
+```
+
+### FTP
+
+Store files on FTP servers.
+
+```ts
+import { FTPStorageProvider, Storage } from '@devbro/neko-storage';
+
+const provider = new FTPStorageProvider({
+  engine: 'ftp',
+  basePath: '/remote/path',
+  ftpConfig: {
+    host: 'ftp.example.com',
+    port: 21,
+    user: 'username',
+    password: 'password',
+    secure: false, // Set to true for FTPS
+  },
+});
+const storage = new Storage(provider);
+```
+
+### SFTP
+
+Store files on SFTP servers via SSH.
+
+```ts
+import { SFTPStorageProvider, Storage } from '@devbro/neko-storage';
+
+const provider = new SFTPStorageProvider({
+  engine: 'sftp',
+  basePath: '/remote/path',
+  sftpConfig: {
+    host: 'sftp.example.com',
+    port: 22,
+    username: 'username',
+    password: 'password',
+    // Or use private key authentication
+    // privateKey: fs.readFileSync('/path/to/private-key'),
+    // passphrase: 'key-passphrase',
+  },
+});
+const storage = new Storage(provider);
 ```
 
 More driver available upon request or through PR.

package/dist/Storage.d.mts

@@ -3,6 +3,7 @@ import { Stream } from 'stream';
 import { Metadata } from './types.mjs';
 import { StorageProviderInterface } from './StorageProviderInterface.mjs';
 import '@aws-sdk/client-s3';
+import '@google-cloud/storage';
 
 declare class Storage {
     protected provider: StorageProviderInterface;

package/dist/Storage.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/Storage.mts"],"sourcesContent":["import { ReadStream } from 'fs';\nimport { Stream } from 'stream';\nimport { Metadata } from './types.mjs';\nimport { StorageConfig } from './types.mjs';\nimport { StorageProviderInterface } from './StorageProviderInterface.mjs';\n\nexport class Storage {\n  constructor(protected provider: StorageProviderInterface) {}\n\n  exists(path: string): Promise<boolean> {\n    return this.provider.exists(path);\n  }\n  \n  put(path: string, content: string | object | Stream | Buffer): Promise<boolean> {\n    return this.provider.put(path, content);\n  }\n  \n  getJson(path: string): Promise<object> {\n    return this.provider.getJson(path);\n  }\n  \n  getString(path: string): Promise<string> {\n    return this.provider.getString(path);\n  }\n  \n  getBuffer(path: string): Promise<Buffer> {\n    return this.provider.getBuffer(path);\n  }\n  \n  getStream(path: string): Promise<ReadStream> {\n    return this.provider.getStream(path);\n  }\n  \n  delete(path: string): Promise<boolean> {\n    return this.provider.delete(path);\n  }\n  \n  metadata(path: string): Promise<Metadata> {\n    return this.provider.metadata(path);\n  }\n}\n"],"mappings":";;AAMO,MAAM,QAAQ;AAAA,EACnB,YAAsB,UAAoC;AAApC;AAAA,EAAqC;AAAA,EAP7D,OAMqB;AAAA;AAAA;AAAA,EAGnB,OAAO,MAAgC;AACrC,WAAO,KAAK,SAAS,OAAO,IAAI;AAAA,EAClC;AAAA,EAEA,IAAI,MAAc,SAA8D;AAC9E,WAAO,KAAK,SAAS,IAAI,MAAM,OAAO;AAAA,EACxC;AAAA,EAEA,QAAQ,MAA+B;AACrC,WAAO,KAAK,SAAS,QAAQ,IAAI;AAAA,EACnC;AAAA,EAEA,UAAU,MAA+B;AACvC,WAAO,KAAK,SAAS,UAAU,IAAI;AAAA,EACrC;AAAA,EAEA,UAAU,MAA+B;AACvC,WAAO,KAAK,SAAS,UAAU,IAAI;AAAA,EACrC;AAAA,EAEA,UAAU,MAAmC;AAC3C,WAAO,KAAK,SAAS,UAAU,IAAI;AAAA,EACrC;AAAA,EAEA,OAAO,MAAgC;AACrC,WAAO,KAAK,SAAS,OAAO,IAAI;AAAA,EAClC;AAAA,EAEA,SAAS,MAAiC;AACxC,WAAO,KAAK,SAAS,SAAS,IAAI;AAAA,EACpC;AACF;","names":[]}
+{"version":3,"sources":["../src/Storage.mts"],"sourcesContent":["import { ReadStream } from 'fs';\nimport { Stream } from 'stream';\nimport { Metadata } from './types.mjs';\nimport { StorageProviderInterface } from './StorageProviderInterface.mjs';\n\nexport class Storage {\n  constructor(protected provider: StorageProviderInterface) {}\n\n  exists(path: string): Promise<boolean> {\n    return this.provider.exists(path);\n  }\n\n  put(path: string, content: string | object | Stream | Buffer): Promise<boolean> {\n    return this.provider.put(path, content);\n  }\n\n  getJson(path: string): Promise<object> {\n    return this.provider.getJson(path);\n  }\n\n  getString(path: string): Promise<string> {\n    return this.provider.getString(path);\n  }\n\n  getBuffer(path: string): Promise<Buffer> {\n    return this.provider.getBuffer(path);\n  }\n\n  getStream(path: string): Promise<ReadStream> {\n    return this.provider.getStream(path);\n  }\n\n  delete(path: string): Promise<boolean> {\n    return this.provider.delete(path);\n  }\n\n  metadata(path: string): Promise<Metadata> {\n    return this.provider.metadata(path);\n  }\n}\n"],"mappings":";;AAKO,MAAM,QAAQ;AAAA,EACnB,YAAsB,UAAoC;AAApC;AAAA,EAAqC;AAAA,EAN7D,OAKqB;AAAA;AAAA;AAAA,EAGnB,OAAO,MAAgC;AACrC,WAAO,KAAK,SAAS,OAAO,IAAI;AAAA,EAClC;AAAA,EAEA,IAAI,MAAc,SAA8D;AAC9E,WAAO,KAAK,SAAS,IAAI,MAAM,OAAO;AAAA,EACxC;AAAA,EAEA,QAAQ,MAA+B;AACrC,WAAO,KAAK,SAAS,QAAQ,IAAI;AAAA,EACnC;AAAA,EAEA,UAAU,MAA+B;AACvC,WAAO,KAAK,SAAS,UAAU,IAAI;AAAA,EACrC;AAAA,EAEA,UAAU,MAA+B;AACvC,WAAO,KAAK,SAAS,UAAU,IAAI;AAAA,EACrC;AAAA,EAEA,UAAU,MAAmC;AAC3C,WAAO,KAAK,SAAS,UAAU,IAAI;AAAA,EACrC;AAAA,EAEA,OAAO,MAAgC;AACrC,WAAO,KAAK,SAAS,OAAO,IAAI;AAAA,EAClC;AAAA,EAEA,SAAS,MAAiC;AACxC,WAAO,KAAK,SAAS,SAAS,IAAI;AAAA,EACpC;AACF;","names":[]}

package/dist/StorageProviderFactory.d.mts

@@ -4,11 +4,12 @@ import 'fs';
 import 'stream';
 import './types.mjs';
 import '@aws-sdk/client-s3';
+import '@google-cloud/storage';
 
 declare class StorageProviderFactory {
     static instance: FlexibleFactory<StorageProviderInterface>;
     static register(key: string, factory: (...args: any[]) => StorageProviderInterface): void;
-    static create<T>(key: string, ...args: any[]): StorageProviderInterface;
+    static create(key: string, ...args: any[]): StorageProviderInterface;
 }
 
 export { StorageProviderFactory };

package/dist/StorageProviderFactory.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/StorageProviderFactory.mts"],"sourcesContent":["import { Storage } from './Storage.mjs';\nimport { FlexibleFactory } from '@devbro/neko-helper';\nimport { StorageProviderInterface } from './StorageProviderInterface.mjs';\n\nexport class StorageProviderFactory {\n  static instance: FlexibleFactory<StorageProviderInterface> = new FlexibleFactory<StorageProviderInterface>();\n\n  static register(key: string, factory: (...args: any[]) => StorageProviderInterface): void {\n    StorageProviderFactory.instance.register(key, factory);\n  }\n\n  static create<T>(key: string, ...args: any[]): StorageProviderInterface {\n    return StorageProviderFactory.instance.create(key, ...args);\n  }\n}\n"],"mappings":";;AACA,SAAS,uBAAuB;AAGzB,MAAM,uBAAuB;AAAA,EAJpC,OAIoC;AAAA;AAAA;AAAA,EAClC,OAAO,WAAsD,IAAI,gBAA0C;AAAA,EAE3G,OAAO,SAAS,KAAa,SAA6D;AACxF,2BAAuB,SAAS,SAAS,KAAK,OAAO;AAAA,EACvD;AAAA,EAEA,OAAO,OAAU,QAAgB,MAAuC;AACtE,WAAO,uBAAuB,SAAS,OAAO,KAAK,GAAG,IAAI;AAAA,EAC5D;AACF;","names":[]}
+{"version":3,"sources":["../src/StorageProviderFactory.mts"],"sourcesContent":["import { FlexibleFactory } from '@devbro/neko-helper';\nimport { StorageProviderInterface } from './StorageProviderInterface.mjs';\n\nexport class StorageProviderFactory {\n  static instance: FlexibleFactory<StorageProviderInterface> =\n    new FlexibleFactory<StorageProviderInterface>();\n\n  static register(key: string, factory: (...args: any[]) => StorageProviderInterface): void {\n    StorageProviderFactory.instance.register(key, factory);\n  }\n\n  static create(key: string, ...args: any[]): StorageProviderInterface {\n    return StorageProviderFactory.instance.create(key, ...args);\n  }\n}\n"],"mappings":";;AAAA,SAAS,uBAAuB;AAGzB,MAAM,uBAAuB;AAAA,EAHpC,OAGoC;AAAA;AAAA;AAAA,EAClC,OAAO,WACL,IAAI,gBAA0C;AAAA,EAEhD,OAAO,SAAS,KAAa,SAA6D;AACxF,2BAAuB,SAAS,SAAS,KAAK,OAAO;AAAA,EACvD;AAAA,EAEA,OAAO,OAAO,QAAgB,MAAuC;AACnE,WAAO,uBAAuB,SAAS,OAAO,KAAK,GAAG,IAAI;AAAA,EAC5D;AACF;","names":[]}

package/dist/StorageProviderInterface.d.mts

@@ -2,6 +2,7 @@ import { ReadStream } from 'fs';
 import { Stream } from 'stream';
 import { Metadata } from './types.mjs';
 import '@aws-sdk/client-s3';
+import '@google-cloud/storage';
 
 interface StorageProviderInterface {
     exists(path: string): Promise<boolean>;

package/dist/index.d.mts

@@ -1,10 +1,15 @@
-export { Metadata, StorageConfig } from './types.mjs';
+export { AzureStorageConfig, FTPConfig, GCPStorageConfig, LocalStorageConfig, Metadata, S3ClientConfig, SFTPConfig, StorageConfig } from './types.mjs';
 export { Storage } from './Storage.mjs';
 export { AWSS3StorageProvider } from './providers/AWSS3StorageProvider.mjs';
 export { LocalStorageProvider } from './providers/LocalStorageProvider.mjs';
+export { GCPStorageProvider } from './providers/GCPStorageProvider.mjs';
+export { AzureBlobStorageProvider } from './providers/AzureBlobStorageProvider.mjs';
+export { FTPStorageProvider } from './providers/FTPStorageProvider.mjs';
+export { SFTPStorageProvider } from './providers/SFTPStorageProvider.mjs';
 export { StorageProviderFactory } from './StorageProviderFactory.mjs';
 export { StorageProviderInterface } from './StorageProviderInterface.mjs';
 import '@aws-sdk/client-s3';
+import '@google-cloud/storage';
 import 'fs';
 import 'stream';
 import '@devbro/neko-helper';

package/dist/index.js

@@ -32,7 +32,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AWSS3StorageProvider: () => AWSS3StorageProvider,
+  AzureBlobStorageProvider: () => AzureBlobStorageProvider,
+  FTPStorageProvider: () => FTPStorageProvider,
+  GCPStorageProvider: () => GCPStorageProvider,
   LocalStorageProvider: () => LocalStorageProvider,
+  SFTPStorageProvider: () => SFTPStorageProvider,
   Storage: () => Storage,
   StorageProviderFactory: () => StorageProviderFactory
 });
@@ -78,7 +82,7 @@ var import_stream = __toESM(require("stream"), 1);
 var AWSS3StorageProvider = class {
   constructor(config) {
     this.config = config;
-    this.s3 = new import_client_s3.S3Client(this.config?.s3Config || {});
+    this.s3 = new import_client_s3.S3Client(this.config);
   }
   static {
     __name(this, "AWSS3StorageProvider");
@@ -86,7 +90,7 @@ var AWSS3StorageProvider = class {
   s3;
   async exists(path2) {
     try {
-      await this.s3.send(new import_client_s3.HeadObjectCommand({ Bucket: this.config?.bucket, Key: path2 }));
+      await this.s3.send(new import_client_s3.HeadObjectCommand({ Bucket: this.config.bucket, Key: path2 }));
       return true;
     } catch (error) {
       if (error.name === "NotFound") {
@@ -250,6 +254,436 @@ var LocalStorageProvider = class {
   }
 };
 
+// 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);
+    });
+  }
+};
+
+// 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) {
+        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();
+    }
+  }
+  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 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();
+    }
+  }
+  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;
+  }
+  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();
+    }
+  }
+};
+
+// 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();
+    }
+  }
+  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 {
@@ -267,7 +701,11 @@ var StorageProviderFactory = class _StorageProviderFactory {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AWSS3StorageProvider,
+  AzureBlobStorageProvider,
+  FTPStorageProvider,
+  GCPStorageProvider,
   LocalStorageProvider,
+  SFTPStorageProvider,
   Storage,
   StorageProviderFactory
 });