@devbro/neko-storage 0.1.0

package/dist/AWSS3Storage.d.mts

@@ -0,0 +1,23 @@
+import { StorageConfig, Metadata } from './types.mjs';
+import { Storage } from './Storage.mjs';
+import { ReadStream } from 'fs';
+import Stream from 'stream';
+import '@aws-sdk/client-s3';
+
+declare class AWSS3Storage extends Storage {
+    protected config: StorageConfig;
+    private s3;
+    constructor(config: StorageConfig);
+    static canHandle(config: StorageConfig): boolean;
+    exists(path: string): Promise<boolean>;
+    put(path: string, content: string | object | Stream | Buffer): Promise<boolean>;
+    getJson(path: string): Promise<object>;
+    getString(path: string): Promise<string>;
+    delete(path: string): Promise<boolean>;
+    private streamToString;
+    getBuffer(path: string): Promise<Buffer>;
+    getStream(path: string): Promise<ReadStream>;
+    metadata(path: string): Promise<Metadata>;
+}
+
+export { AWSS3Storage };

package/dist/AWSS3Storage.d.ts

@@ -0,0 +1,23 @@
+import { StorageConfig, Metadata } from './types.js';
+import { Storage } from './Storage.js';
+import { ReadStream } from 'fs';
+import Stream from 'stream';
+import '@aws-sdk/client-s3';
+
+declare class AWSS3Storage extends Storage {
+    protected config: StorageConfig;
+    private s3;
+    constructor(config: StorageConfig);
+    static canHandle(config: StorageConfig): boolean;
+    exists(path: string): Promise<boolean>;
+    put(path: string, content: string | object | Stream | Buffer): Promise<boolean>;
+    getJson(path: string): Promise<object>;
+    getString(path: string): Promise<string>;
+    delete(path: string): Promise<boolean>;
+    private streamToString;
+    getBuffer(path: string): Promise<Buffer>;
+    getStream(path: string): Promise<ReadStream>;
+    metadata(path: string): Promise<Metadata>;
+}
+
+export { AWSS3Storage };

package/dist/AWSS3Storage.js

@@ -0,0 +1,194 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+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());
+  });
+};
+var AWSS3Storage_exports = {};
+__export(AWSS3Storage_exports, {
+  AWSS3Storage: () => AWSS3Storage
+});
+module.exports = __toCommonJS(AWSS3Storage_exports);
+var import_Storage = require("./Storage");
+var import_client_s3 = require("@aws-sdk/client-s3");
+var import_stream = __toESM(require("stream"));
+const _AWSS3Storage = class _AWSS3Storage extends import_Storage.Storage {
+  constructor(config) {
+    var _a;
+    super(config);
+    __publicField(this, "config");
+    __publicField(this, "s3");
+    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) || {});
+  }
+  static canHandle(config) {
+    return config.engine === "s3";
+  }
+  exists(path) {
+    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: path
+        }));
+        return true;
+      } catch (error) {
+        if (error.name === "NotFound") {
+          return false;
+        }
+        throw error;
+      }
+    });
+  }
+  put(path, 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: path,
+        Body: body
+      }));
+      return true;
+    });
+  }
+  getJson(path) {
+    return __async(this, null, function* () {
+      const data = yield this.s3.send(new import_client_s3.GetObjectCommand({
+        Bucket: this.config.bucket,
+        Key: path
+      }));
+      const body = yield this.streamToString(data.Body);
+      return JSON.parse(body);
+    });
+  }
+  getString(path) {
+    return __async(this, null, function* () {
+      const data = yield this.s3.send(new import_client_s3.GetObjectCommand({
+        Bucket: this.config.bucket,
+        Key: path
+      }));
+      return yield this.streamToString(data.Body);
+    });
+  }
+  delete(path) {
+    return __async(this, null, function* () {
+      yield this.s3.send(new import_client_s3.DeleteObjectCommand({
+        Bucket: this.config.bucket,
+        Key: path
+      }));
+      return true;
+    });
+  }
+  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);
+      });
+    });
+  }
+  getBuffer(path) {
+    return __async(this, null, function* () {
+      const data = yield this.s3.send(new import_client_s3.GetObjectCommand({
+        Bucket: this.config.bucket,
+        Key: path
+      }));
+      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);
+      });
+    });
+  }
+  getStream(path) {
+    return __async(this, null, function* () {
+      const data = yield this.s3.send(new import_client_s3.GetObjectCommand({
+        Bucket: this.config.bucket,
+        Key: path
+      }));
+      return data.Body;
+    });
+  }
+  metadata(path) {
+    return __async(this, null, function* () {
+      const metadata = yield this.s3.send(new import_client_s3.HeadObjectCommand({
+        Bucket: this.config.bucket,
+        Key: path
+      }));
+      return {
+        size: metadata.ContentLength || 0,
+        mimeType: metadata.ContentType || "unknown",
+        lastModifiedDate: (metadata.LastModified || /* @__PURE__ */ new Date(0)).toISOString()
+      };
+    });
+  }
+};
+__name(_AWSS3Storage, "AWSS3Storage");
+let AWSS3Storage = _AWSS3Storage;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AWSS3Storage
+});
+//# sourceMappingURL=AWSS3Storage.js.map

package/dist/AWSS3Storage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/AWSS3Storage.ts"],"sourcesContent":["import { Metadata, StorageConfig } from './types';\nimport { Storage } from './Storage';\nimport {\n  S3Client,\n  HeadObjectCommand,\n  PutObjectCommand,\n  GetObjectCommand,\n  DeleteObjectCommand,\n  HeadObjectOutput,\n} from '@aws-sdk/client-s3';\nimport { ReadStream } from 'fs';\nimport Stream, { Readable } from 'stream';\n\nexport class AWSS3Storage extends Storage {\n  private s3: S3Client;\n\n  constructor(protected config: StorageConfig) {\n    super(config);\n\n    if (!AWSS3Storage.canHandle(config)) {\n      throw new Error(`storage engine cannot handle this config.`);\n    }\n\n    this.s3 = new S3Client(this.config?.s3Config || {});\n  }\n\n  static canHandle(config: StorageConfig): boolean {\n    return config.engine === 's3';\n  }\n\n  async exists(path: string): Promise<boolean> {\n    try {\n      await this.s3.send(new HeadObjectCommand({ Bucket: this.config?.bucket, Key: path }));\n      return true;\n    } catch (error: any) {\n      if (error.name === 'NotFound') {\n        return false;\n      }\n      throw error;\n    }\n  }\n\n  async put(path: string, content: string | object | Stream | Buffer): Promise<boolean> {\n    let body: any;\n    if (typeof content === 'string' || content instanceof Buffer) {\n      body = content;\n    } else if (typeof content === 'object' && !(content instanceof Stream)) {\n      body = JSON.stringify(content);\n    } else if (content instanceof Stream) {\n      body = content;\n    } else {\n      throw new Error('Unsupported content type');\n    }\n\n    await this.s3.send(\n      new PutObjectCommand({\n        Bucket: this.config.bucket,\n        Key: path,\n        Body: body,\n      })\n    );\n\n    return true;\n  }\n\n  async getJson(path: string): Promise<object> {\n    const data = await this.s3.send(\n      new GetObjectCommand({ Bucket: this.config.bucket, Key: path })\n    );\n    const body = await this.streamToString(data.Body as Stream);\n    return JSON.parse(body);\n  }\n\n  async getString(path: string): Promise<string> {\n    const data = await this.s3.send(\n      new GetObjectCommand({ Bucket: this.config.bucket, Key: path })\n    );\n    return await this.streamToString(data.Body as Stream);\n  }\n\n  async delete(path: string): Promise<boolean> {\n    await this.s3.send(new DeleteObjectCommand({ Bucket: this.config.bucket, Key: path }));\n    return true;\n  }\n\n  private async streamToString(stream: Stream): Promise<string> {\n    return new Promise((resolve, reject) => {\n      const chunks: Uint8Array[] = [];\n      stream.on('data', (chunk) => chunks.push(chunk));\n      stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));\n      stream.on('error', reject);\n    });\n  }\n\n  async getBuffer(path: string): Promise<Buffer> {\n    const data = await this.s3.send(\n      new GetObjectCommand({ Bucket: this.config.bucket, Key: path })\n    );\n    const chunks: Uint8Array[] = [];\n    const stream = data.Body as Readable;\n\n    return new Promise((resolve, reject) => {\n      stream.on('data', (chunk) => chunks.push(chunk));\n      stream.on('end', () => resolve(Buffer.concat(chunks)));\n      stream.on('error', reject);\n    });\n  }\n\n  async getStream(path: string): Promise<ReadStream> {\n    const data = await this.s3.send(\n      new GetObjectCommand({ Bucket: this.config.bucket, Key: path })\n    );\n    return data.Body as unknown as ReadStream;\n  }\n\n  async metadata(path: string): Promise<Metadata> {\n    const metadata = await this.s3.send(\n      new HeadObjectCommand({ Bucket: this.config.bucket, Key: path })\n    );\n    return {\n      size: metadata.ContentLength || 0,\n      mimeType: metadata.ContentType || 'unknown',\n      lastModifiedDate: (metadata.LastModified || new Date(0)).toISOString(),\n    };\n  }\n}\n"],"mappings":"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","names":["AWSS3Storage","Storage","config","s3","canHandle","Error","S3Client","s3Config","engine","exists","path","send","HeadObjectCommand","Bucket","bucket","Key","error","name","put","content","body","Buffer","Stream","JSON","stringify","PutObjectCommand","Body","getJson","data","GetObjectCommand","streamToString","parse","getString","delete","DeleteObjectCommand","stream","Promise","resolve","reject","chunks","on","chunk","push","concat","toString","getBuffer","getStream","metadata","size","ContentLength","mimeType","ContentType","lastModifiedDate","LastModified","Date","toISOString"]}

package/dist/AWSS3Storage.mjs

@@ -0,0 +1,161 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+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());
+  });
+};
+import { Storage } from "./Storage";
+import { S3Client, HeadObjectCommand, PutObjectCommand, GetObjectCommand, DeleteObjectCommand } from "@aws-sdk/client-s3";
+import Stream from "stream";
+const _AWSS3Storage = class _AWSS3Storage extends Storage {
+  constructor(config) {
+    var _a;
+    super(config);
+    __publicField(this, "config");
+    __publicField(this, "s3");
+    this.config = config;
+    if (!_AWSS3Storage.canHandle(config)) {
+      throw new Error(`storage engine cannot handle this config.`);
+    }
+    this.s3 = new S3Client(((_a = this.config) == null ? void 0 : _a.s3Config) || {});
+  }
+  static canHandle(config) {
+    return config.engine === "s3";
+  }
+  exists(path) {
+    return __async(this, null, function* () {
+      var _a;
+      try {
+        yield this.s3.send(new HeadObjectCommand({
+          Bucket: (_a = this.config) == null ? void 0 : _a.bucket,
+          Key: path
+        }));
+        return true;
+      } catch (error) {
+        if (error.name === "NotFound") {
+          return false;
+        }
+        throw error;
+      }
+    });
+  }
+  put(path, content) {
+    return __async(this, null, function* () {
+      let body;
+      if (typeof content === "string" || content instanceof Buffer) {
+        body = content;
+      } else if (typeof content === "object" && !(content instanceof Stream)) {
+        body = JSON.stringify(content);
+      } else if (content instanceof Stream) {
+        body = content;
+      } else {
+        throw new Error("Unsupported content type");
+      }
+      yield this.s3.send(new PutObjectCommand({
+        Bucket: this.config.bucket,
+        Key: path,
+        Body: body
+      }));
+      return true;
+    });
+  }
+  getJson(path) {
+    return __async(this, null, function* () {
+      const data = yield this.s3.send(new GetObjectCommand({
+        Bucket: this.config.bucket,
+        Key: path
+      }));
+      const body = yield this.streamToString(data.Body);
+      return JSON.parse(body);
+    });
+  }
+  getString(path) {
+    return __async(this, null, function* () {
+      const data = yield this.s3.send(new GetObjectCommand({
+        Bucket: this.config.bucket,
+        Key: path
+      }));
+      return yield this.streamToString(data.Body);
+    });
+  }
+  delete(path) {
+    return __async(this, null, function* () {
+      yield this.s3.send(new DeleteObjectCommand({
+        Bucket: this.config.bucket,
+        Key: path
+      }));
+      return true;
+    });
+  }
+  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);
+      });
+    });
+  }
+  getBuffer(path) {
+    return __async(this, null, function* () {
+      const data = yield this.s3.send(new GetObjectCommand({
+        Bucket: this.config.bucket,
+        Key: path
+      }));
+      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);
+      });
+    });
+  }
+  getStream(path) {
+    return __async(this, null, function* () {
+      const data = yield this.s3.send(new GetObjectCommand({
+        Bucket: this.config.bucket,
+        Key: path
+      }));
+      return data.Body;
+    });
+  }
+  metadata(path) {
+    return __async(this, null, function* () {
+      const metadata = yield this.s3.send(new HeadObjectCommand({
+        Bucket: this.config.bucket,
+        Key: path
+      }));
+      return {
+        size: metadata.ContentLength || 0,
+        mimeType: metadata.ContentType || "unknown",
+        lastModifiedDate: (metadata.LastModified || /* @__PURE__ */ new Date(0)).toISOString()
+      };
+    });
+  }
+};
+__name(_AWSS3Storage, "AWSS3Storage");
+let AWSS3Storage = _AWSS3Storage;
+export {
+  AWSS3Storage
+};
+//# sourceMappingURL=AWSS3Storage.mjs.map

package/dist/AWSS3Storage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/AWSS3Storage.ts"],"sourcesContent":["import { Metadata, StorageConfig } from './types';\nimport { Storage } from './Storage';\nimport {\n  S3Client,\n  HeadObjectCommand,\n  PutObjectCommand,\n  GetObjectCommand,\n  DeleteObjectCommand,\n  HeadObjectOutput,\n} from '@aws-sdk/client-s3';\nimport { ReadStream } from 'fs';\nimport Stream, { Readable } from 'stream';\n\nexport class AWSS3Storage extends Storage {\n  private s3: S3Client;\n\n  constructor(protected config: StorageConfig) {\n    super(config);\n\n    if (!AWSS3Storage.canHandle(config)) {\n      throw new Error(`storage engine cannot handle this config.`);\n    }\n\n    this.s3 = new S3Client(this.config?.s3Config || {});\n  }\n\n  static canHandle(config: StorageConfig): boolean {\n    return config.engine === 's3';\n  }\n\n  async exists(path: string): Promise<boolean> {\n    try {\n      await this.s3.send(new HeadObjectCommand({ Bucket: this.config?.bucket, Key: path }));\n      return true;\n    } catch (error: any) {\n      if (error.name === 'NotFound') {\n        return false;\n      }\n      throw error;\n    }\n  }\n\n  async put(path: string, content: string | object | Stream | Buffer): Promise<boolean> {\n    let body: any;\n    if (typeof content === 'string' || content instanceof Buffer) {\n      body = content;\n    } else if (typeof content === 'object' && !(content instanceof Stream)) {\n      body = JSON.stringify(content);\n    } else if (content instanceof Stream) {\n      body = content;\n    } else {\n      throw new Error('Unsupported content type');\n    }\n\n    await this.s3.send(\n      new PutObjectCommand({\n        Bucket: this.config.bucket,\n        Key: path,\n        Body: body,\n      })\n    );\n\n    return true;\n  }\n\n  async getJson(path: string): Promise<object> {\n    const data = await this.s3.send(\n      new GetObjectCommand({ Bucket: this.config.bucket, Key: path })\n    );\n    const body = await this.streamToString(data.Body as Stream);\n    return JSON.parse(body);\n  }\n\n  async getString(path: string): Promise<string> {\n    const data = await this.s3.send(\n      new GetObjectCommand({ Bucket: this.config.bucket, Key: path })\n    );\n    return await this.streamToString(data.Body as Stream);\n  }\n\n  async delete(path: string): Promise<boolean> {\n    await this.s3.send(new DeleteObjectCommand({ Bucket: this.config.bucket, Key: path }));\n    return true;\n  }\n\n  private async streamToString(stream: Stream): Promise<string> {\n    return new Promise((resolve, reject) => {\n      const chunks: Uint8Array[] = [];\n      stream.on('data', (chunk) => chunks.push(chunk));\n      stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));\n      stream.on('error', reject);\n    });\n  }\n\n  async getBuffer(path: string): Promise<Buffer> {\n    const data = await this.s3.send(\n      new GetObjectCommand({ Bucket: this.config.bucket, Key: path })\n    );\n    const chunks: Uint8Array[] = [];\n    const stream = data.Body as Readable;\n\n    return new Promise((resolve, reject) => {\n      stream.on('data', (chunk) => chunks.push(chunk));\n      stream.on('end', () => resolve(Buffer.concat(chunks)));\n      stream.on('error', reject);\n    });\n  }\n\n  async getStream(path: string): Promise<ReadStream> {\n    const data = await this.s3.send(\n      new GetObjectCommand({ Bucket: this.config.bucket, Key: path })\n    );\n    return data.Body as unknown as ReadStream;\n  }\n\n  async metadata(path: string): Promise<Metadata> {\n    const metadata = await this.s3.send(\n      new HeadObjectCommand({ Bucket: this.config.bucket, Key: path })\n    );\n    return {\n      size: metadata.ContentLength || 0,\n      mimeType: metadata.ContentType || 'unknown',\n      lastModifiedDate: (metadata.LastModified || new Date(0)).toISOString(),\n    };\n  }\n}\n"],"mappings":"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","names":["Storage","S3Client","HeadObjectCommand","PutObjectCommand","GetObjectCommand","DeleteObjectCommand","Stream","AWSS3Storage","config","s3","canHandle","Error","s3Config","engine","exists","path","send","Bucket","bucket","Key","error","name","put","content","body","Buffer","JSON","stringify","Body","getJson","data","streamToString","parse","getString","delete","stream","Promise","resolve","reject","chunks","on","chunk","push","concat","toString","getBuffer","getStream","metadata","size","ContentLength","mimeType","ContentType","lastModifiedDate","LastModified","Date","toISOString"]}

package/dist/LocalStorage.d.mts

@@ -0,0 +1,21 @@
+import Stream from 'stream';
+import { ReadStream } from 'fs';
+import { StorageConfig, Metadata } from './types.mjs';
+import { Storage } from './Storage.mjs';
+import '@aws-sdk/client-s3';
+
+declare class LocalStorage extends Storage {
+    constructor(config: StorageConfig);
+    metadata(path: string): Promise<Metadata>;
+    static canHandle(config: StorageConfig): boolean;
+    getFullPath(filePath: string): string;
+    exists(path: string): Promise<boolean>;
+    put(path: string, content: string | object | Stream | Buffer): Promise<boolean>;
+    getJson(path: string): Promise<object>;
+    getString(path: string, encoding?: BufferEncoding): Promise<string>;
+    getBuffer(path: string): Promise<Buffer>;
+    getStream(path: string): Promise<ReadStream>;
+    delete(path: string): Promise<boolean>;
+}
+
+export { LocalStorage };

package/dist/LocalStorage.d.ts

@@ -0,0 +1,21 @@
+import Stream from 'stream';
+import { ReadStream } from 'fs';
+import { StorageConfig, Metadata } from './types.js';
+import { Storage } from './Storage.js';
+import '@aws-sdk/client-s3';
+
+declare class LocalStorage extends Storage {
+    constructor(config: StorageConfig);
+    metadata(path: string): Promise<Metadata>;
+    static canHandle(config: StorageConfig): boolean;
+    getFullPath(filePath: string): string;
+    exists(path: string): Promise<boolean>;
+    put(path: string, content: string | object | Stream | Buffer): Promise<boolean>;
+    getJson(path: string): Promise<object>;
+    getString(path: string, encoding?: BufferEncoding): Promise<string>;
+    getBuffer(path: string): Promise<Buffer>;
+    getStream(path: string): Promise<ReadStream>;
+    delete(path: string): Promise<boolean>;
+}
+
+export { LocalStorage };

package/dist/LocalStorage.js

@@ -0,0 +1,162 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  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());
+  });
+};
+var LocalStorage_exports = {};
+__export(LocalStorage_exports, {
+  LocalStorage: () => LocalStorage
+});
+module.exports = __toCommonJS(LocalStorage_exports);
+var import_stream = __toESM(require("stream"));
+var fs = __toESM(require("fs/promises"));
+var import_fs = require("fs");
+var path = __toESM(require("path"));
+var mime = __toESM(require("mime-types"));
+var import_Storage = require("./Storage");
+const _LocalStorage = class _LocalStorage extends import_Storage.Storage {
+  constructor(config) {
+    super(config);
+    if (!_LocalStorage.canHandle(config)) {
+      throw new Error(`storage engine cannot handle this 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 canHandle(config) {
+    if (config.engine === "local") {
+      return true;
+    }
+    return false;
+  }
+  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;
+      }
+    });
+  }
+  put(path2, content) {
+    return __async(this, null, function* () {
+      const fullPath = this.getFullPath(path2);
+      if (typeof content === "string" || content instanceof Buffer) {
+        yield fs.writeFile(fullPath, content);
+      } else if (typeof content === "object" && !(content instanceof import_stream.default)) {
+        yield fs.writeFile(fullPath, JSON.stringify(content, null, 2));
+      } else if (typeof content === "object" && content instanceof import_stream.default) {
+        const writeStream = (0, import_fs.createWriteStream)(fullPath);
+        yield new Promise((resolve, reject) => {
+          content.pipe(writeStream);
+          content.on("end", resolve);
+          content.on("error", reject);
+        });
+      } else {
+        throw new Error("Unsupported content type");
+      }
+      return true;
+    });
+  }
+  getJson(path2) {
+    return __async(this, null, function* () {
+      const fullPath = this.getFullPath(path2);
+      const content = yield fs.readFile(fullPath, "utf-8");
+      return JSON.parse(content);
+    });
+  }
+  getString(path2, encoding = "utf-8") {
+    return __async(this, null, function* () {
+      const fullPath = this.getFullPath(path2);
+      return yield fs.readFile(fullPath, encoding);
+    });
+  }
+  getBuffer(path2) {
+    return __async(this, null, function* () {
+      const fullPath = this.getFullPath(path2);
+      return yield fs.readFile(fullPath);
+    });
+  }
+  getStream(path2) {
+    return __async(this, null, function* () {
+      const fullPath = this.getFullPath(path2);
+      return (0, import_fs.createReadStream)(fullPath);
+    });
+  }
+  delete(path2) {
+    return __async(this, null, function* () {
+      const fullPath = this.getFullPath(path2);
+      yield fs.unlink(fullPath);
+      return true;
+    });
+  }
+};
+__name(_LocalStorage, "LocalStorage");
+let LocalStorage = _LocalStorage;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalStorage
+});
+//# sourceMappingURL=LocalStorage.js.map

package/dist/LocalStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/LocalStorage.ts"],"sourcesContent":["import Stream from 'stream';\nimport * as fs from 'fs/promises';\nimport { createWriteStream, createReadStream, ReadStream } from 'fs';\nimport * as path from 'path';\nimport * as mime from 'mime-types';\nimport { Metadata, StorageConfig } from './types';\nimport { Storage } from './Storage';\n\nexport class LocalStorage extends Storage {\n  constructor(config: StorageConfig) {\n    super(config);\n\n    if (!LocalStorage.canHandle(config)) {\n      throw new Error(`storage engine cannot handle this config.`);\n    }\n    // Ensure the base folder exists\n    fs.mkdir(this.config.basePath, { recursive: true }).catch((error) => {\n      throw error;\n    });\n  }\n\n  async metadata(path: string): Promise<Metadata> {\n    const fullPath = this.getFullPath(path);\n    const stats = await fs.stat(fullPath);\n    return {\n      size: stats.size,\n      mimeType: mime.lookup(fullPath) || 'unknown',\n      lastModifiedDate: stats.mtime.toISOString(),\n    };\n  }\n\n  static canHandle(config: StorageConfig) {\n    if (config.engine === 'local') {\n      return true;\n    }\n    return false;\n  }\n\n  getFullPath(filePath: string) {\n    return path.join(this.config.basePath, filePath);\n  }\n\n  async exists(path: string): Promise<boolean> {\n    try {\n      await fs.access(this.getFullPath(path));\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  async put(path: string, content: string | object | Stream | Buffer): Promise<boolean> {\n    const fullPath = this.getFullPath(path);\n\n    if (typeof content === 'string' || content instanceof Buffer) {\n      await fs.writeFile(fullPath, content);\n    } else if (typeof content === 'object' && !(content instanceof Stream)) {\n      await fs.writeFile(fullPath, JSON.stringify(content, null, 2));\n    } else if (typeof content === 'object' && content instanceof Stream) {\n      const writeStream = createWriteStream(fullPath);\n      await new Promise((resolve, reject) => {\n        (content as Stream).pipe(writeStream);\n        (content as Stream).on('end', resolve);\n        (content as Stream).on('error', reject);\n      });\n    } else {\n      throw new Error('Unsupported content type');\n    }\n\n    return true;\n  }\n\n  async getJson(path: string): Promise<object> {\n    const fullPath = this.getFullPath(path);\n    const content = await fs.readFile(fullPath, 'utf-8');\n    return JSON.parse(content);\n  }\n\n  async getString(path: string, encoding: BufferEncoding = 'utf-8'): Promise<string> {\n    const fullPath = this.getFullPath(path);\n    return await fs.readFile(fullPath, encoding);\n  }\n\n  async getBuffer(path: string): Promise<Buffer> {\n    const fullPath = this.getFullPath(path);\n    return await fs.readFile(fullPath);\n  }\n\n  async getStream(path: string): Promise<ReadStream> {\n    const fullPath = this.getFullPath(path);\n    return createReadStream(fullPath);\n  }\n\n  async delete(path: string): Promise<boolean> {\n    const fullPath = this.getFullPath(path);\n    await fs.unlink(fullPath);\n    return true;\n  }\n}\n"],"mappings":"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","names":["LocalStorage","Storage","config","canHandle","Error","fs","mkdir","basePath","recursive","catch","error","metadata","path","fullPath","getFullPath","stats","stat","size","mimeType","mime","lookup","lastModifiedDate","mtime","toISOString","engine","filePath","join","exists","access","put","content","Buffer","writeFile","Stream","JSON","stringify","writeStream","createWriteStream","Promise","resolve","reject","pipe","on","getJson","readFile","parse","getString","encoding","getBuffer","getStream","createReadStream","delete","unlink"]}

package/dist/LocalStorage.mjs

@@ -0,0 +1,129 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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());
+  });
+};
+import Stream from "stream";
+import * as fs from "fs/promises";
+import { createWriteStream, createReadStream } from "fs";
+import * as path from "path";
+import * as mime from "mime-types";
+import { Storage } from "./Storage";
+const _LocalStorage = class _LocalStorage extends Storage {
+  constructor(config) {
+    super(config);
+    if (!_LocalStorage.canHandle(config)) {
+      throw new Error(`storage engine cannot handle this 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 canHandle(config) {
+    if (config.engine === "local") {
+      return true;
+    }
+    return false;
+  }
+  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;
+      }
+    });
+  }
+  put(path2, content) {
+    return __async(this, null, function* () {
+      const fullPath = this.getFullPath(path2);
+      if (typeof content === "string" || content instanceof Buffer) {
+        yield fs.writeFile(fullPath, content);
+      } else if (typeof content === "object" && !(content instanceof Stream)) {
+        yield fs.writeFile(fullPath, JSON.stringify(content, null, 2));
+      } else if (typeof content === "object" && content instanceof Stream) {
+        const writeStream = createWriteStream(fullPath);
+        yield new Promise((resolve, reject) => {
+          content.pipe(writeStream);
+          content.on("end", resolve);
+          content.on("error", reject);
+        });
+      } else {
+        throw new Error("Unsupported content type");
+      }
+      return true;
+    });
+  }
+  getJson(path2) {
+    return __async(this, null, function* () {
+      const fullPath = this.getFullPath(path2);
+      const content = yield fs.readFile(fullPath, "utf-8");
+      return JSON.parse(content);
+    });
+  }
+  getString(path2, encoding = "utf-8") {
+    return __async(this, null, function* () {
+      const fullPath = this.getFullPath(path2);
+      return yield fs.readFile(fullPath, encoding);
+    });
+  }
+  getBuffer(path2) {
+    return __async(this, null, function* () {
+      const fullPath = this.getFullPath(path2);
+      return yield fs.readFile(fullPath);
+    });
+  }
+  getStream(path2) {
+    return __async(this, null, function* () {
+      const fullPath = this.getFullPath(path2);
+      return createReadStream(fullPath);
+    });
+  }
+  delete(path2) {
+    return __async(this, null, function* () {
+      const fullPath = this.getFullPath(path2);
+      yield fs.unlink(fullPath);
+      return true;
+    });
+  }
+};
+__name(_LocalStorage, "LocalStorage");
+let LocalStorage = _LocalStorage;
+export {
+  LocalStorage
+};
+//# sourceMappingURL=LocalStorage.mjs.map

package/dist/LocalStorage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/LocalStorage.ts"],"sourcesContent":["import Stream from 'stream';\nimport * as fs from 'fs/promises';\nimport { createWriteStream, createReadStream, ReadStream } from 'fs';\nimport * as path from 'path';\nimport * as mime from 'mime-types';\nimport { Metadata, StorageConfig } from './types';\nimport { Storage } from './Storage';\n\nexport class LocalStorage extends Storage {\n  constructor(config: StorageConfig) {\n    super(config);\n\n    if (!LocalStorage.canHandle(config)) {\n      throw new Error(`storage engine cannot handle this config.`);\n    }\n    // Ensure the base folder exists\n    fs.mkdir(this.config.basePath, { recursive: true }).catch((error) => {\n      throw error;\n    });\n  }\n\n  async metadata(path: string): Promise<Metadata> {\n    const fullPath = this.getFullPath(path);\n    const stats = await fs.stat(fullPath);\n    return {\n      size: stats.size,\n      mimeType: mime.lookup(fullPath) || 'unknown',\n      lastModifiedDate: stats.mtime.toISOString(),\n    };\n  }\n\n  static canHandle(config: StorageConfig) {\n    if (config.engine === 'local') {\n      return true;\n    }\n    return false;\n  }\n\n  getFullPath(filePath: string) {\n    return path.join(this.config.basePath, filePath);\n  }\n\n  async exists(path: string): Promise<boolean> {\n    try {\n      await fs.access(this.getFullPath(path));\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  async put(path: string, content: string | object | Stream | Buffer): Promise<boolean> {\n    const fullPath = this.getFullPath(path);\n\n    if (typeof content === 'string' || content instanceof Buffer) {\n      await fs.writeFile(fullPath, content);\n    } else if (typeof content === 'object' && !(content instanceof Stream)) {\n      await fs.writeFile(fullPath, JSON.stringify(content, null, 2));\n    } else if (typeof content === 'object' && content instanceof Stream) {\n      const writeStream = createWriteStream(fullPath);\n      await new Promise((resolve, reject) => {\n        (content as Stream).pipe(writeStream);\n        (content as Stream).on('end', resolve);\n        (content as Stream).on('error', reject);\n      });\n    } else {\n      throw new Error('Unsupported content type');\n    }\n\n    return true;\n  }\n\n  async getJson(path: string): Promise<object> {\n    const fullPath = this.getFullPath(path);\n    const content = await fs.readFile(fullPath, 'utf-8');\n    return JSON.parse(content);\n  }\n\n  async getString(path: string, encoding: BufferEncoding = 'utf-8'): Promise<string> {\n    const fullPath = this.getFullPath(path);\n    return await fs.readFile(fullPath, encoding);\n  }\n\n  async getBuffer(path: string): Promise<Buffer> {\n    const fullPath = this.getFullPath(path);\n    return await fs.readFile(fullPath);\n  }\n\n  async getStream(path: string): Promise<ReadStream> {\n    const fullPath = this.getFullPath(path);\n    return createReadStream(fullPath);\n  }\n\n  async delete(path: string): Promise<boolean> {\n    const fullPath = this.getFullPath(path);\n    await fs.unlink(fullPath);\n    return true;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,OAAOA,YAAY;AACnB,YAAYC,QAAQ;AACpB,SAASC,mBAAmBC,wBAAoC;AAChE,YAAYC,UAAU;AACtB,YAAYC,UAAU;AAEtB,SAASC,eAAe;AAEjB,MAAMC,gBAAN,MAAMA,sBAAqBD,QAAAA;EAChC,YAAYE,QAAuB;AACjC,UAAMA,MAAAA;AAEN,QAAI,CAACD,cAAaE,UAAUD,MAAAA,GAAS;AACnC,YAAM,IAAIE,MAAM,2CAA2C;IAC7D;AAEAT,OAAGU,MAAM,KAAKH,OAAOI,UAAU;MAAEC,WAAW;IAAK,CAAA,EAAGC,MAAM,CAACC,UAAAA;AACzD,YAAMA;IACR,CAAA;EACF;EAEMC,SAASZ,OAAiC;;AAC9C,YAAMa,WAAW,KAAKC,YAAYd,KAAAA;AAClC,YAAMe,QAAQ,MAAMlB,GAAGmB,KAAKH,QAAAA;AAC5B,aAAO;QACLI,MAAMF,MAAME;QACZC,UAAUjB,KAAKkB,OAAON,QAAAA,KAAa;QACnCO,kBAAkBL,MAAMM,MAAMC,YAAW;MAC3C;IACF;;EAEA,OAAOjB,UAAUD,QAAuB;AACtC,QAAIA,OAAOmB,WAAW,SAAS;AAC7B,aAAO;IACT;AACA,WAAO;EACT;EAEAT,YAAYU,UAAkB;AAC5B,WAAOxB,KAAKyB,KAAK,KAAKrB,OAAOI,UAAUgB,QAAAA;EACzC;EAEME,OAAO1B,OAAgC;;AAC3C,UAAI;AACF,cAAMH,GAAG8B,OAAO,KAAKb,YAAYd,KAAAA,CAAAA;AACjC,eAAO;MACT,SAAQ;AACN,eAAO;MACT;IACF;;EAEM4B,IAAI5B,OAAc6B,SAA8D;;AACpF,YAAMhB,WAAW,KAAKC,YAAYd,KAAAA;AAElC,UAAI,OAAO6B,YAAY,YAAYA,mBAAmBC,QAAQ;AAC5D,cAAMjC,GAAGkC,UAAUlB,UAAUgB,OAAAA;MAC/B,WAAW,OAAOA,YAAY,YAAY,EAAEA,mBAAmBjC,SAAS;AACtE,cAAMC,GAAGkC,UAAUlB,UAAUmB,KAAKC,UAAUJ,SAAS,MAAM,CAAA,CAAA;MAC7D,WAAW,OAAOA,YAAY,YAAYA,mBAAmBjC,QAAQ;AACnE,cAAMsC,cAAcpC,kBAAkBe,QAAAA;AACtC,cAAM,IAAIsB,QAAQ,CAACC,SAASC,WAAAA;AACzBR,kBAAmBS,KAAKJ,WAAAA;AACxBL,kBAAmBU,GAAG,OAAOH,OAAAA;AAC7BP,kBAAmBU,GAAG,SAASF,MAAAA;QAClC,CAAA;MACF,OAAO;AACL,cAAM,IAAI/B,MAAM,0BAAA;MAClB;AAEA,aAAO;IACT;;EAEMkC,QAAQxC,OAA+B;;AAC3C,YAAMa,WAAW,KAAKC,YAAYd,KAAAA;AAClC,YAAM6B,UAAU,MAAMhC,GAAG4C,SAAS5B,UAAU,OAAA;AAC5C,aAAOmB,KAAKU,MAAMb,OAAAA;IACpB;;EAEMc,UAAU3C,OAAc4C,WAA2B,SAA0B;;AACjF,YAAM/B,WAAW,KAAKC,YAAYd,KAAAA;AAClC,aAAO,MAAMH,GAAG4C,SAAS5B,UAAU+B,QAAAA;IACrC;;EAEMC,UAAU7C,OAA+B;;AAC7C,YAAMa,WAAW,KAAKC,YAAYd,KAAAA;AAClC,aAAO,MAAMH,GAAG4C,SAAS5B,QAAAA;IAC3B;;EAEMiC,UAAU9C,OAAmC;;AACjD,YAAMa,WAAW,KAAKC,YAAYd,KAAAA;AAClC,aAAOD,iBAAiBc,QAAAA;IAC1B;;EAEMkC,OAAO/C,OAAgC;;AAC3C,YAAMa,WAAW,KAAKC,YAAYd,KAAAA;AAClC,YAAMH,GAAGmD,OAAOnC,QAAAA;AAChB,aAAO;IACT;;AACF;AA1FkCX;AAA3B,IAAMC,eAAN;","names":["Stream","fs","createWriteStream","createReadStream","path","mime","Storage","LocalStorage","config","canHandle","Error","mkdir","basePath","recursive","catch","error","metadata","fullPath","getFullPath","stats","stat","size","mimeType","lookup","lastModifiedDate","mtime","toISOString","engine","filePath","join","exists","access","put","content","Buffer","writeFile","JSON","stringify","writeStream","Promise","resolve","reject","pipe","on","getJson","readFile","parse","getString","encoding","getBuffer","getStream","delete","unlink"]}

package/dist/Storage.d.mts

@@ -0,0 +1,20 @@
+import { ReadStream } from 'fs';
+import { Stream } from 'stream';
+import { StorageConfig, Metadata } from './types.mjs';
+import '@aws-sdk/client-s3';
+
+declare abstract class Storage {
+    protected config: StorageConfig;
+    constructor(config: StorageConfig);
+    static canHandle(config: StorageConfig): boolean;
+    abstract exists(path: string): Promise<boolean>;
+    abstract put(path: string, content: string | object | Stream | Buffer): Promise<boolean>;
+    abstract getJson(path: string): Promise<object>;
+    abstract getString(path: string): Promise<string>;
+    abstract getBuffer(path: string): Promise<Buffer>;
+    abstract getStream(path: string): Promise<ReadStream>;
+    abstract delete(path: string): Promise<boolean>;
+    abstract metadata(path: string): Promise<Metadata>;
+}
+
+export { Storage };

package/dist/Storage.d.ts

@@ -0,0 +1,20 @@
+import { ReadStream } from 'fs';
+import { Stream } from 'stream';
+import { StorageConfig, Metadata } from './types.js';
+import '@aws-sdk/client-s3';
+
+declare abstract class Storage {
+    protected config: StorageConfig;
+    constructor(config: StorageConfig);
+    static canHandle(config: StorageConfig): boolean;
+    abstract exists(path: string): Promise<boolean>;
+    abstract put(path: string, content: string | object | Stream | Buffer): Promise<boolean>;
+    abstract getJson(path: string): Promise<object>;
+    abstract getString(path: string): Promise<string>;
+    abstract getBuffer(path: string): Promise<Buffer>;
+    abstract getStream(path: string): Promise<ReadStream>;
+    abstract delete(path: string): Promise<boolean>;
+    abstract metadata(path: string): Promise<Metadata>;
+}
+
+export { Storage };

package/dist/Storage.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var Storage_exports = {};
+__export(Storage_exports, {
+  Storage: () => Storage
+});
+module.exports = __toCommonJS(Storage_exports);
+const _Storage = class _Storage {
+  constructor(config) {
+    __publicField(this, "config");
+    this.config = config;
+  }
+  static canHandle(config) {
+    throw new Error("Method not implemented.");
+  }
+};
+__name(_Storage, "Storage");
+let Storage = _Storage;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Storage
+});
+//# sourceMappingURL=Storage.js.map

package/dist/Storage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Storage.ts"],"sourcesContent":["import { ReadStream } from 'fs';\nimport { Stream } from 'stream';\nimport { Metadata } from './types';\nimport { StorageConfig } from './types';\n\nexport abstract class Storage {\n  constructor(protected config: StorageConfig) {}\n\n  static canHandle(config: StorageConfig): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  abstract exists(path: string): Promise<boolean>;\n  abstract put(path: string, content: string | object | Stream | Buffer): Promise<boolean>;\n  abstract getJson(path: string): Promise<object>;\n  abstract getString(path: string): Promise<string>;\n  abstract getBuffer(path: string): Promise<Buffer>;\n  abstract getStream(path: string): Promise<ReadStream>;\n  abstract delete(path: string): Promise<boolean>;\n  abstract metadata(path: string): Promise<Metadata>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAKA;;;;;AAAO,MAAeA,WAAf,MAAeA,SAAAA;EACpB,YAAsBC,QAAuB;;SAAvBA,SAAAA;EAAwB;EAE9C,OAAOC,UAAUD,QAAgC;AAC/C,UAAM,IAAIE,MAAM,yBAAA;EAClB;AAUF;AAfsBH;AAAf,IAAeA,UAAf;","names":["Storage","config","canHandle","Error"]}

package/dist/Storage.mjs

@@ -0,0 +1,19 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const _Storage = class _Storage {
+  constructor(config) {
+    __publicField(this, "config");
+    this.config = config;
+  }
+  static canHandle(config) {
+    throw new Error("Method not implemented.");
+  }
+};
+__name(_Storage, "Storage");
+let Storage = _Storage;
+export {
+  Storage
+};
+//# sourceMappingURL=Storage.mjs.map

package/dist/Storage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Storage.ts"],"sourcesContent":["import { ReadStream } from 'fs';\nimport { Stream } from 'stream';\nimport { Metadata } from './types';\nimport { StorageConfig } from './types';\n\nexport abstract class Storage {\n  constructor(protected config: StorageConfig) {}\n\n  static canHandle(config: StorageConfig): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  abstract exists(path: string): Promise<boolean>;\n  abstract put(path: string, content: string | object | Stream | Buffer): Promise<boolean>;\n  abstract getJson(path: string): Promise<object>;\n  abstract getString(path: string): Promise<string>;\n  abstract getBuffer(path: string): Promise<Buffer>;\n  abstract getStream(path: string): Promise<ReadStream>;\n  abstract delete(path: string): Promise<boolean>;\n  abstract metadata(path: string): Promise<Metadata>;\n}\n"],"mappings":";;;;AAKO,MAAeA,WAAf,MAAeA,SAAAA;EACpB,YAAsBC,QAAuB;;SAAvBA,SAAAA;EAAwB;EAE9C,OAAOC,UAAUD,QAAgC;AAC/C,UAAM,IAAIE,MAAM,yBAAA;EAClB;AAUF;AAfsBH;AAAf,IAAeA,UAAf;","names":["Storage","config","canHandle","Error"]}

package/dist/StorageFactory.d.mts

@@ -0,0 +1,13 @@
+import { Storage } from './Storage.mjs';
+import { StorageConfig } from './types.mjs';
+import 'fs';
+import 'stream';
+import '@aws-sdk/client-s3';
+
+declare class StorageFactory {
+    static storageEngines: (typeof Storage)[];
+    registerStorageEngine(engine: typeof Storage): void;
+    static create(config: StorageConfig): Storage;
+}
+
+export { StorageFactory };

package/dist/StorageFactory.d.ts

@@ -0,0 +1,13 @@
+import { Storage } from './Storage.js';
+import { StorageConfig } from './types.js';
+import 'fs';
+import 'stream';
+import '@aws-sdk/client-s3';
+
+declare class StorageFactory {
+    static storageEngines: (typeof Storage)[];
+    registerStorageEngine(engine: typeof Storage): void;
+    static create(config: StorageConfig): Storage;
+}
+
+export { StorageFactory };

package/dist/StorageFactory.js

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var StorageFactory_exports = {};
+__export(StorageFactory_exports, {
+  StorageFactory: () => StorageFactory
+});
+module.exports = __toCommonJS(StorageFactory_exports);
+var import_AWSS3Storage = require("./AWSS3Storage");
+var import_LocalStorage = require("./LocalStorage");
+const _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);
+      }
+    }
+    throw new Error("No matchin storage engine found");
+  }
+};
+__name(_StorageFactory, "StorageFactory");
+__publicField(_StorageFactory, "storageEngines", [
+  import_LocalStorage.LocalStorage,
+  import_AWSS3Storage.AWSS3Storage
+]);
+let StorageFactory = _StorageFactory;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StorageFactory
+});
+//# sourceMappingURL=StorageFactory.js.map

package/dist/StorageFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/StorageFactory.ts"],"sourcesContent":["import { AWSS3Storage } from './AWSS3Storage';\nimport { LocalStorage } from './LocalStorage';\nimport { Storage } from './Storage';\nimport { StorageConfig } from './types';\n\nexport class StorageFactory {\n  public static storageEngines: (typeof Storage)[] = [LocalStorage, AWSS3Storage];\n\n  registerStorageEngine(engine: typeof Storage) {\n    StorageFactory.storageEngines.push(engine);\n  }\n\n  public static create(config: StorageConfig): Storage {\n    for (const engine of StorageFactory.storageEngines) {\n      if (engine.canHandle(config)) {\n        // @ts-ignore\n        return new engine(config);\n      }\n    }\n    throw new Error('No matchin storage engine found');\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AAAA,0BAA6B;AAC7B,0BAA6B;AAItB,MAAMA,kBAAN,MAAMA,gBAAAA;EAGXC,sBAAsBC,QAAwB;AAC5CF,oBAAeG,eAAeC,KAAKF,MAAAA;EACrC;EAEA,OAAcG,OAAOC,QAAgC;AACnD,eAAWJ,UAAUF,gBAAeG,gBAAgB;AAClD,UAAID,OAAOK,UAAUD,MAAAA,GAAS;AAE5B,eAAO,IAAIJ,OAAOI,MAAAA;MACpB;IACF;AACA,UAAM,IAAIE,MAAM,iCAAA;EAClB;AACF;AAhBaR;AACX,cADWA,iBACGG,kBAAqC;EAACM;EAAcC;;AAD7D,IAAMV,iBAAN;","names":["StorageFactory","registerStorageEngine","engine","storageEngines","push","create","config","canHandle","Error","LocalStorage","AWSS3Storage"]}

package/dist/StorageFactory.mjs

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { AWSS3Storage } from "./AWSS3Storage";
+import { LocalStorage } from "./LocalStorage";
+const _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);
+      }
+    }
+    throw new Error("No matchin storage engine found");
+  }
+};
+__name(_StorageFactory, "StorageFactory");
+__publicField(_StorageFactory, "storageEngines", [
+  LocalStorage,
+  AWSS3Storage
+]);
+let StorageFactory = _StorageFactory;
+export {
+  StorageFactory
+};
+//# sourceMappingURL=StorageFactory.mjs.map

package/dist/StorageFactory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/StorageFactory.ts"],"sourcesContent":["import { AWSS3Storage } from './AWSS3Storage';\nimport { LocalStorage } from './LocalStorage';\nimport { Storage } from './Storage';\nimport { StorageConfig } from './types';\n\nexport class StorageFactory {\n  public static storageEngines: (typeof Storage)[] = [LocalStorage, AWSS3Storage];\n\n  registerStorageEngine(engine: typeof Storage) {\n    StorageFactory.storageEngines.push(engine);\n  }\n\n  public static create(config: StorageConfig): Storage {\n    for (const engine of StorageFactory.storageEngines) {\n      if (engine.canHandle(config)) {\n        // @ts-ignore\n        return new engine(config);\n      }\n    }\n    throw new Error('No matchin storage engine found');\n  }\n}\n"],"mappings":";;;;AAAA,SAASA,oBAAoB;AAC7B,SAASC,oBAAoB;AAItB,MAAMC,kBAAN,MAAMA,gBAAAA;EAGXC,sBAAsBC,QAAwB;AAC5CF,oBAAeG,eAAeC,KAAKF,MAAAA;EACrC;EAEA,OAAcG,OAAOC,QAAgC;AACnD,eAAWJ,UAAUF,gBAAeG,gBAAgB;AAClD,UAAID,OAAOK,UAAUD,MAAAA,GAAS;AAE5B,eAAO,IAAIJ,OAAOI,MAAAA;MACpB;IACF;AACA,UAAM,IAAIE,MAAM,iCAAA;EAClB;AACF;AAhBaR;AACX,cADWA,iBACGG,kBAAqC;EAACJ;EAAcD;;AAD7D,IAAME,iBAAN;","names":["AWSS3Storage","LocalStorage","StorageFactory","registerStorageEngine","engine","storageEngines","push","create","config","canHandle","Error"]}

package/dist/index.d.mts

@@ -0,0 +1,8 @@
+export { Metadata, StorageConfig } from './types.mjs';
+export { Storage } from './Storage.mjs';
+export { AWSS3Storage } from './AWSS3Storage.mjs';
+export { LocalStorage } from './LocalStorage.mjs';
+export { StorageFactory } from './StorageFactory.mjs';
+import '@aws-sdk/client-s3';
+import 'fs';
+import 'stream';

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { Metadata, StorageConfig } from './types.js';
+export { Storage } from './Storage.js';
+export { AWSS3Storage } from './AWSS3Storage.js';
+export { LocalStorage } from './LocalStorage.js';
+export { StorageFactory } from './StorageFactory.js';
+import '@aws-sdk/client-s3';
+import 'fs';
+import 'stream';

package/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./types"), module.exports);
+__reExport(index_exports, require("./Storage"), module.exports);
+__reExport(index_exports, require("./AWSS3Storage"), module.exports);
+__reExport(index_exports, require("./LocalStorage"), module.exports);
+__reExport(index_exports, require("./StorageFactory"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./types"),
+  ...require("./Storage"),
+  ...require("./AWSS3Storage"),
+  ...require("./LocalStorage"),
+  ...require("./StorageFactory")
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './types';\nexport * from './Storage';\nexport * from './AWSS3Storage';\nexport * from './LocalStorage';\nexport * from './StorageFactory';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;;0BAAc,oBAAd;AACA,0BAAc,sBADd;AAEA,0BAAc,2BAFd;AAGA,0BAAc,2BAHd;AAIA,0BAAc,6BAJd;","names":[]}

package/dist/index.mjs

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./Storage";
+export * from "./AWSS3Storage";
+export * from "./LocalStorage";
+export * from "./StorageFactory";
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './types';\nexport * from './Storage';\nexport * from './AWSS3Storage';\nexport * from './LocalStorage';\nexport * from './StorageFactory';\n"],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;","names":[]}

package/dist/types.d.mts

@@ -0,0 +1,15 @@
+import { S3ClientConfig } from '@aws-sdk/client-s3';
+
+type Metadata = {
+    size: number;
+    mimeType: string;
+    lastModifiedDate: string;
+};
+type StorageConfig = {
+    engine: string;
+    basePath: string;
+    bucket?: string;
+    s3Config?: S3ClientConfig;
+};
+
+export type { Metadata, StorageConfig };

package/dist/types.d.ts

@@ -0,0 +1,15 @@
+import { S3ClientConfig } from '@aws-sdk/client-s3';
+
+type Metadata = {
+    size: number;
+    mimeType: string;
+    lastModifiedDate: string;
+};
+type StorageConfig = {
+    engine: string;
+    basePath: string;
+    bucket?: string;
+    s3Config?: S3ClientConfig;
+};
+
+export type { Metadata, StorageConfig };

package/dist/types.js

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import { S3ClientConfig } from '@aws-sdk/client-s3';\n\nexport type Metadata = {\n  size: number;\n  mimeType: string;\n  lastModifiedDate: string;\n};\n\nexport type StorageConfig = {\n  engine: string;\n  basePath: string;\n  bucket?: string;\n  s3Config?: S3ClientConfig;\n};\n"],"mappings":";;;;;;;;;;;;;;AAQA;;","names":[]}

package/dist/types.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=types.mjs.map

package/dist/types.mjs.map

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

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@devbro/neko-storage",
+  "version": "0.1.0",
+  "description": "abstracted file storage implementation",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "jest",
+    "format": "eslint . --fix --ext ts,tsx --report-unused-disable-directives --max-warnings 0 ",
+    "prepare": "husky",
+    "prettier": "prettier --write .",
+    "clean": "rm -rf dist"
+  },
+  "author": "Farzad Meow Khalafi",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^22.14.1",
+    "@typescript-eslint/eslint-plugin": "^7.1.1",
+    "@typescript-eslint/parser": "^7.1.1",
+    "eslint": "8.57.0",
+    "husky": "^9.1.7",
+    "jest": "^29.7.0",
+    "pinst": "^3.0.0",
+    "prettier": "^3.5.3",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.0.2",
+    "typescript": "^5.3.3",
+    "@types/mime-types": "^2.1.4"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.817.0",
+    "mime-types": "^3.0.1"
+  },
+  "directories": {
+    "doc": "docs",
+    "test": "tests"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/devbro1/pashmak.git"
+  },
+  "keywords": [
+    "@devbro/neko-storage",
+    "devbro",
+    "neko-storage",
+    "file storage",
+    "file management"
+  ],
+  "bugs": {
+    "url": "https://github.com/devbro1/pashmak/issues"
+  },
+  "homepage": "https://devbro1.github.io/pashmak/",
+  "tags": {
+    "needsCompile": true,
+    "canPublishToNpm": true
+  }
+}