@bejibun/storage 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,44 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+---
+
+## [v0.1.0](https://github.com/Bejibun-Framework/bejibun-storage/compare/v0.1.0...v0.1.0) - 2026-08-03
+
+### 🩹 Fixes
+
+### 📖 Changes
+Initial release of `@bejibun/storage` -- a filesystem abstraction for the Bejibun Framework, providing a single API over local disk and S3-compatible storage.
+
+**Disk drivers:**
+- `local` -- reads/writes files on the local filesystem
+- `s3` -- reads/writes files to an S3-compatible bucket (endpoint, region, bucket, credentials configurable)
+  **`Storage` facade / `StorageBuilder`:**
+- `.disk(name)` -- select a configured disk by name
+- `.build(disk)` -- use an ad-hoc disk config at runtime, without touching `config/storage.ts`
+- `.exists(path)` / `.missing(path)` -- check file presence
+- `.metadata(path)` -- get file `Stats` (local) or `S3Stats` (S3)
+- `.size(path)` -- get file size in bytes
+- `.mimeType(path)` -- detect file MIME type
+- `.lastModified(path)` -- get last-modified date
+- `.get(path)` -- retrieve a `Bun.BunFile` or `Bun.S3File`
+- `.put(path, content, options?)` -- write content to a file
+- `.copy(source, destination, options?)` -- copy a file
+- `.move(source, destination, options?)` -- move a file
+- `.delete(path)` -- delete a file
+  **Config:**
+- `config/storage.ts` supports a `default` disk plus a `disks` map; ships with `local`, `public`, and `s3` examples
+- Per-operation `StorageOptions` cover S3-specific concerns (`acl`, `storageClass`, `partSize`, `queueSize`, `retry`, `virtualHostedStyle`, etc.) as well as local options (`mode`, `createPath`)
+- `StorageDiskDriverEnum` (`Local` | `S3`) used to identify the driver per disk
+  **Error handling:**
+- `StorageException` -- thrown for missing/invalid config, unsupported drivers, and missing required arguments; logs via `@bejibun/logger` before throwing
+
+**Dependencies:**
+- `@bejibun/app ^0.1.24`
+- `@bejibun/logger ^0.1.22`
+- `@bejibun/utils ^0.1.28`
+
+### ❤️Contributors
+- Havea Crenata ([@crenata](https://github.com/crenata))
+
+**Full Changelog**: https://github.com/Bejibun-Framework/bejibun-storage/blob/master/CHANGELOG.md

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Bejibun Framework
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,145 @@
+<div align="center">
+
+<img src="https://github.com/Bejibun-Framework/bejibun/blob/master/public/images/bejibun.png?raw=true" width="150" alt="Bejibun" />
+
+![GitHub top language](https://img.shields.io/github/languages/top/Bejibun-Framework/bejibun-storage)
+![NPM Downloads](https://img.shields.io/npm/d18m/%40bejibun%2Fstorage)
+![GitHub issues](https://img.shields.io/github/issues/Bejibun-Framework/bejibun-storage)
+![GitHub](https://img.shields.io/github/license/Bejibun-Framework/bejibun-storage)
+![GitHub release (latest by date including pre-releases)](https://img.shields.io/github/v/release/Bejibun-Framework/bejibun-storage?display_name=tag&include_prereleases)
+
+</div>
+
+# Storage for Bejibun
+Storage for Bejibun Framework.
+
+## Usage
+
+### Installation
+Install the package.
+
+```bash
+# Using Bun
+bun add @bejibun/storage
+
+# Using Bejibun
+bun ace install @bejibun/storage
+```
+
+### Configuration
+The configuration file automatically executed if you are using `ace`.
+
+Or
+
+Add `storage.ts` inside config directory on your project if doesn't exist.
+
+```bash
+config/storage.ts
+```
+
+```ts
+import App from "@bejibun/app";
+import StorageDiskDriverEnum from "@/enums/StorageDiskDriverEnum";
+
+const config: Record<string, any> = {
+    default: "local",
+
+    disks: {
+        local: {
+            driver: StorageDiskDriverEnum.Local,
+            root: App.Path.storagePath("app")
+        },
+
+        public: {
+            driver: StorageDiskDriverEnum.Local,
+            root: App.Path.storagePath("app/public"),
+            url: `${Bun.env.APP_URL}/storage/public`
+        },
+
+        s3: {
+            driver: StorageDiskDriverEnum.S3,
+            endpoint: Bun.env.S3_ENDPOINT,
+            region: Bun.env.S3_REGION,
+            bucket: Bun.env.S3_BUCKET,
+            access_key_id: Bun.env.S3_ACCESS_KEY_ID,
+            secret_access_key: Bun.env.S3_SECRET_ACCESS_KEY,
+            url: ""
+        }
+    }
+};
+
+export default config;
+```
+
+You can pass the value with environment variables.
+
+### How to Use
+How to use tha package.
+
+#### Standard Use
+```ts
+import Storage from "@bejibun/core/facades/Storage";
+
+await Storage.exists("path/to/your/file.ext"); // Check if the file exists
+await Storage.missing("path/to/your/file.ext"); // Check if the file doesn't exists
+await Storage.get("path/to/your/file.ext"); // Get data content
+await Storage.put("path/to/your/file.ext", "content"); // Store content to file
+await Storage.copy("source/file.ext", "destination/file.ext"); // Copy file
+await Storage.move("source/file.ext", "destination/file.ext"); // Move file
+await Storage.delete("path/to/your/file.ext"); // Delete file
+```
+
+#### With Specified Disk
+```ts
+import Storage from "@bejibun/core/facades/Storage";
+
+await Storage.disk("public").exists("path/to/your/file.ext");
+await Storage.disk("public").missing("path/to/your/file.ext");
+await Storage.disk("public").get("path/to/your/file.ext");
+await Storage.disk("public").put("path/to/your/file.ext", "content");
+await Storage.disk("public").copy("source/file.ext", "destination/file.ext");
+await Storage.disk("public").move("source/file.ext", "destination/file.ext");
+await Storage.disk("public").delete("path/to/your/file.ext");
+```
+
+#### New Disk at Runtime
+```ts
+import Storage from "@bejibun/core/facades/Storage";
+
+await Storage.build({
+    driver: "local", // "local" | StorageDiskDriverEnum.Local
+    root: App.Path.storagePath("custom")
+}).exists("path/to/your/file.ext");
+await Storage.build({
+    driver: "local",
+    root: App.Path.storagePath("custom")
+}).missing("path/to/your/file.ext");
+await Storage.build({
+    driver: "local",
+    root: App.Path.storagePath("custom")
+}).get("path/to/your/file.ext");
+await Storage.build({
+    driver: "local",
+    root: App.Path.storagePath("custom")
+}).put("path/to/your/file.ext", "content");
+await Storage.build({
+    driver: "local",
+    root: App.Path.storagePath("custom")
+}).copy("source/file.ext", "destination/file.ext");
+await Storage.build({
+    driver: "local",
+    root: App.Path.storagePath("custom")
+}).move("source/file.ext", "destination/file.ext");
+await Storage.build({
+    driver: "local",
+    root: App.Path.storagePath("custom")
+}).delete("path/to/your/file.ext");
+```
+
+## ☕ Support / Donate
+
+If you find this project helpful and want to support it:
+
+[![Donate](https://img.shields.io/badge/Donate-Support%20Me-orange?style=for-the-badge)](https://donate.bejibun.com)
+
+Or you can buy this `$BJBN (Bejibun)` tokens [here](https://pump.fun/coin/CQhbNnCGKfDaKXt8uE61i5DrBYJV7NPsCDD9vQgypump).

package/builders/StorageBuilder.d.ts

@@ -0,0 +1,24 @@
+import type { Stats } from "fs";
+import type { StorageDisk, StorageOptions } from "../types/storage";
+export default class StorageBuilder {
+    protected conf: Record<string, any>;
+    protected overrideDisk?: StorageDisk;
+    protected drive?: string;
+    constructor();
+    private get config();
+    private get currentDisk();
+    private get driver();
+    build(overrideDisk: StorageDisk): StorageBuilder;
+    disk(drive: string): StorageBuilder;
+    exists(filepath: string): Promise<boolean>;
+    missing(filepath: string): Promise<boolean>;
+    metadata(filepath: string): Promise<Stats | Bun.S3Stats>;
+    size(filepath: string): Promise<number>;
+    mimeType(filepath: string): Promise<string>;
+    lastModified(filepath: string): Promise<Date>;
+    get(filepath: string): Promise<Bun.BunFile | Bun.S3File>;
+    put(filepath: string, content: any, options?: StorageOptions): Promise<void>;
+    copy(source: string, destination: string, options?: StorageOptions): Promise<void>;
+    move(source: string, destination: string, options?: StorageOptions): Promise<void>;
+    delete(filepath: string): Promise<void>;
+}

package/builders/StorageBuilder.js

@@ -0,0 +1,131 @@
+import App from "@bejibun/app";
+import Logger from "@bejibun/logger";
+import { defineValue, isEmpty } from "@bejibun/utils";
+import Enum from "@bejibun/utils/facades/Enum";
+import fs from "fs";
+import StorageLocalBuilder from "../builders/storage/StorageLocalBuilder";
+import StorageS3Builder from "../builders/storage/StorageS3Builder";
+import StorageConfig from "../config/storage";
+import StorageDiskDriverEnum from "../enums/StorageDiskDriverEnum";
+import StorageException from "../exceptions/StorageException";
+export default class StorageBuilder {
+    conf;
+    overrideDisk;
+    drive;
+    constructor() {
+        const configPath = App.Path.configPath("storage.ts");
+        let config;
+        if (fs.existsSync(configPath))
+            config = require(configPath).default;
+        else
+            config = StorageConfig;
+        this.conf = config;
+    }
+    get config() {
+        if (isEmpty(this.conf))
+            throw new StorageException("There is no config provided.");
+        return this.conf;
+    }
+    get currentDisk() {
+        return defineValue(this.overrideDisk, this.config.disks[defineValue(this.drive, this.config.default)]);
+    }
+    get driver() {
+        const driver = defineValue(this.currentDisk?.driver);
+        if (isEmpty(driver))
+            throw new StorageException(`Missing "driver" on disk config.`);
+        if (!Enum.setEnums(StorageDiskDriverEnum).hasValue(driver))
+            throw new StorageException(`Not supported "driver" disk.`);
+        switch (driver) {
+            case StorageDiskDriverEnum.Local:
+                return new StorageLocalBuilder(this.currentDisk);
+            case StorageDiskDriverEnum.S3:
+                return new StorageS3Builder(this.currentDisk);
+            default:
+                throw new StorageException(`Not supported "driver" disk.`);
+        }
+    }
+    build(overrideDisk) {
+        this.overrideDisk = overrideDisk;
+        return this;
+    }
+    disk(drive) {
+        this.drive = drive;
+        return this;
+    }
+    async exists(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return await this.driver.exists(filepath);
+    }
+    async missing(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return !await this.driver.missing(filepath);
+    }
+    async metadata(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return await this.driver.metadata(filepath);
+    }
+    async size(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return await this.driver.size(filepath);
+    }
+    async mimeType(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return await this.driver.mimeType(filepath);
+    }
+    async lastModified(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return await this.driver.lastModified(filepath);
+    }
+    async get(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return await this.driver.get(filepath);
+    }
+    async put(filepath, content, options) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        if (isEmpty(content))
+            throw new StorageException("The content is required.");
+        try {
+            await this.driver.put(filepath, content, options);
+        }
+        catch (error) {
+            Logger.setContext("Storage").error("Something went wrong when saving file.").trace(error);
+        }
+    }
+    async copy(source, destination, options) {
+        if (isEmpty(source))
+            throw new StorageException("The source file path is required.");
+        if (isEmpty(destination))
+            throw new StorageException("The destination file path is required.");
+        try {
+            await this.driver.copy(source, destination, options);
+        }
+        catch (error) {
+            Logger.setContext("Storage").error("Something went wrong when copying file.").trace(error);
+        }
+    }
+    async move(source, destination, options) {
+        if (isEmpty(source))
+            throw new StorageException("The source file path is required.");
+        if (isEmpty(destination))
+            throw new StorageException("The destination file path is required.");
+        try {
+            await this.driver.move(source, destination, options);
+        }
+        catch (error) {
+            Logger.setContext("Storage").error("Something went wrong when moving file.").trace(error);
+        }
+    }
+    async delete(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        await this.driver.delete(filepath);
+    }
+}

package/builders/storage/StorageLocalBuilder.d.ts

@@ -0,0 +1,18 @@
+import type { Stats } from "fs";
+import type { StorageDriver, StorageOptions } from "../../types/storage";
+export default class StorageLocalBuilder implements StorageDriver {
+    protected _config: Record<string, any>;
+    constructor(config: Record<string, any>);
+    private get config();
+    exists(filepath: string): Promise<boolean>;
+    missing(filepath: string): Promise<boolean>;
+    metadata(filepath: string): Promise<Stats>;
+    size(filepath: string): Promise<number>;
+    mimeType(filepath: string): Promise<string>;
+    lastModified(filepath: string): Promise<Date>;
+    get(filepath: string): Promise<Bun.BunFile>;
+    put(filepath: string, content: any, options?: StorageOptions): Promise<void>;
+    copy(source: string, destination: string, options?: StorageOptions): Promise<void>;
+    move(source: string, destination: string, options?: StorageOptions): Promise<void>;
+    delete(filepath: string): Promise<void>;
+}

package/builders/storage/StorageLocalBuilder.js

@@ -0,0 +1,92 @@
+import Logger from "@bejibun/logger";
+import { isEmpty } from "@bejibun/utils";
+import path from "path";
+import StorageException from "../../exceptions/StorageException";
+export default class StorageLocalBuilder {
+    _config;
+    constructor(config) {
+        this._config = config;
+    }
+    get config() {
+        if (isEmpty(this._config.root))
+            throw new StorageException(`Missing "root" for "local" disk configuration.`);
+        return this._config;
+    }
+    async exists(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return await Bun.file(path.resolve(this.config.root, filepath)).exists();
+    }
+    async missing(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return !await this.exists(filepath);
+    }
+    async metadata(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return await (await this.get(filepath)).stat();
+    }
+    async size(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return (await this.metadata(filepath)).size;
+    }
+    async mimeType(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return (await this.get(filepath)).type;
+    }
+    async lastModified(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return (await this.metadata(filepath)).mtime;
+    }
+    async get(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return Bun.file(path.resolve(this.config.root, filepath));
+    }
+    async put(filepath, content, options) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        if (isEmpty(content))
+            throw new StorageException("The content is required.");
+        try {
+            await Bun.write(path.resolve(this.config.root, filepath), content, options);
+        }
+        catch (error) {
+            Logger.setContext("Storage").error("Something went wrong when saving file.").trace(error);
+        }
+    }
+    async copy(source, destination, options) {
+        if (isEmpty(source))
+            throw new StorageException("The source file path is required.");
+        if (isEmpty(destination))
+            throw new StorageException("The destination file path is required.");
+        try {
+            await this.put(destination, await this.get(source), options);
+        }
+        catch (error) {
+            Logger.setContext("Storage").error("Something went wrong when copying file.").trace(error);
+        }
+    }
+    async move(source, destination, options) {
+        if (isEmpty(source))
+            throw new StorageException("The source file path is required.");
+        if (isEmpty(destination))
+            throw new StorageException("The destination file path is required.");
+        try {
+            await this.copy(source, destination, options);
+            await this.delete(source);
+        }
+        catch (error) {
+            Logger.setContext("Storage").error("Something went wrong when moving file.").trace(error);
+        }
+    }
+    async delete(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        await Bun.file(path.resolve(this.config.root, filepath)).delete();
+    }
+}

package/builders/storage/StorageS3Builder.d.ts

@@ -0,0 +1,18 @@
+import type { StorageDriver, StorageOptions } from "../../types/storage";
+export default class StorageS3Builder implements StorageDriver {
+    protected _config: Record<string, any>;
+    protected client: Bun.S3Client;
+    constructor(config: Record<string, any>);
+    private get config();
+    exists(filepath: string): Promise<boolean>;
+    missing(filepath: string): Promise<boolean>;
+    metadata(filepath: string): Promise<Bun.S3Stats>;
+    size(filepath: string): Promise<number>;
+    mimeType(filepath: string): Promise<string>;
+    lastModified(filepath: string): Promise<Date>;
+    get(filepath: string): Promise<Bun.S3File>;
+    put(filepath: string, content: any, options?: StorageOptions): Promise<void>;
+    copy(source: string, destination: string, options?: StorageOptions): Promise<void>;
+    move(source: string, destination: string, options?: StorageOptions): Promise<void>;
+    delete(filepath: string): Promise<void>;
+}

package/builders/storage/StorageS3Builder.js

@@ -0,0 +1,103 @@
+import Logger from "@bejibun/logger";
+import { isEmpty } from "@bejibun/utils";
+import StorageException from "../../exceptions/StorageException";
+export default class StorageS3Builder {
+    _config;
+    client;
+    constructor(config) {
+        this._config = config;
+        this.client = new Bun.S3Client({
+            endpoint: this.config.endpoint,
+            region: this.config.region,
+            bucket: this.config.bucket,
+            accessKeyId: this.config.access_key_id,
+            secretAccessKey: this.config.secret_access_key
+        });
+    }
+    get config() {
+        if (isEmpty(this._config.endpoint))
+            throw new StorageException(`Missing "endpoint" for "s3" disk configuration.`);
+        if (isEmpty(this._config.access_key_id))
+            throw new StorageException(`Missing "access_key_id" for "s3" disk configuration.`);
+        if (isEmpty(this._config.secret_access_key))
+            throw new StorageException(`Missing "secret_access_key" for "s3" disk configuration.`);
+        return this._config;
+    }
+    async exists(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return await this.client.file(filepath).exists();
+    }
+    async missing(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return !await this.exists(filepath);
+    }
+    async metadata(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return await (await this.get(filepath)).stat();
+    }
+    async size(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return (await this.metadata(filepath)).size;
+    }
+    async mimeType(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return (await this.metadata(filepath)).type;
+    }
+    async lastModified(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return (await this.metadata(filepath)).lastModified;
+    }
+    async get(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        return this.client.file(filepath);
+    }
+    async put(filepath, content, options) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        if (isEmpty(content))
+            throw new StorageException("The content is required.");
+        try {
+            await this.client.write(filepath, content, options);
+        }
+        catch (error) {
+            Logger.setContext("Storage").error("Something went wrong when saving file.").trace(error);
+        }
+    }
+    async copy(source, destination, options) {
+        if (isEmpty(source))
+            throw new StorageException("The source file path is required.");
+        if (isEmpty(destination))
+            throw new StorageException("The destination file path is required.");
+        try {
+            await this.put(destination, await this.get(source), options);
+        }
+        catch (error) {
+            Logger.setContext("Storage").error("Something went wrong when copying file.").trace(error);
+        }
+    }
+    async move(source, destination, options) {
+        if (isEmpty(source))
+            throw new StorageException("The source file path is required.");
+        if (isEmpty(destination))
+            throw new StorageException("The destination file path is required.");
+        try {
+            await this.copy(source, destination, options);
+            await this.delete(source);
+        }
+        catch (error) {
+            Logger.setContext("Storage").error("Something went wrong when moving file.").trace(error);
+        }
+    }
+    async delete(filepath) {
+        if (isEmpty(filepath))
+            throw new StorageException("The file path is required.");
+        await this.client.file(filepath).delete();
+    }
+}

package/config/storage.d.ts

@@ -0,0 +1,2 @@
+declare const config: Record<string, any>;
+export default config;

package/config/storage.js

@@ -0,0 +1,26 @@
+import App from "@bejibun/app";
+import StorageDiskDriverEnum from "../enums/StorageDiskDriverEnum";
+const config = {
+    default: "local",
+    disks: {
+        local: {
+            driver: StorageDiskDriverEnum.Local,
+            root: App.Path.storagePath("app")
+        },
+        public: {
+            driver: StorageDiskDriverEnum.Local,
+            root: App.Path.storagePath("app/public"),
+            url: `${Bun.env.APP_URL}/storage/public`
+        },
+        s3: {
+            driver: StorageDiskDriverEnum.S3,
+            endpoint: Bun.env.S3_ENDPOINT,
+            region: Bun.env.S3_REGION,
+            bucket: Bun.env.S3_BUCKET,
+            access_key_id: Bun.env.S3_ACCESS_KEY_ID,
+            secret_access_key: Bun.env.S3_SECRET_ACCESS_KEY,
+            url: ""
+        }
+    }
+};
+export default config;

package/configure.d.ts

@@ -0,0 +1 @@
+export {};

package/configure.js

@@ -0,0 +1,14 @@
+import App from "@bejibun/app";
+import Logger from "@bejibun/logger";
+import path from "path";
+const configPath = path.resolve(__dirname, "config");
+const regex = /\.(m?js|ts)$/;
+const configs = Array.from(new Bun.Glob("**/*").scanSync({
+    cwd: configPath
+})).filter(value => (regex.test(value) &&
+    !value.endsWith(".d.ts")));
+for (const config of configs) {
+    const destination = config.replace(regex, ".ts");
+    await Bun.write(App.Path.configPath(destination), await Bun.file(path.resolve(configPath, config)).text());
+    Logger.setContext("CONFIGURE").info(`Copying ${config} into config/${destination}`);
+}

package/enums/StorageDiskDriverEnum.d.ts

@@ -0,0 +1,5 @@
+declare enum StorageDiskDriverEnum {
+    Local = "local",
+    S3 = "s3"
+}
+export default StorageDiskDriverEnum;

package/enums/StorageDiskDriverEnum.js

@@ -0,0 +1,6 @@
+var StorageDiskDriverEnum;
+(function (StorageDiskDriverEnum) {
+    StorageDiskDriverEnum["Local"] = "local";
+    StorageDiskDriverEnum["S3"] = "s3";
+})(StorageDiskDriverEnum || (StorageDiskDriverEnum = {}));
+export default StorageDiskDriverEnum;

package/enums/index.d.ts

@@ -0,0 +1 @@
+export * from "../enums/StorageDiskDriverEnum";

package/enums/index.js

@@ -0,0 +1 @@
+export * from "../enums/StorageDiskDriverEnum";

package/exceptions/StorageException.d.ts

@@ -0,0 +1,4 @@
+export default class StorageException extends Error {
+    code: number;
+    constructor(message?: string, code?: number);
+}

package/exceptions/StorageException.js

@@ -0,0 +1,14 @@
+import Logger from "@bejibun/logger";
+import { defineValue } from "@bejibun/utils";
+export default class StorageException extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = "StorageException";
+        this.code = defineValue(code, 503);
+        Logger.setContext(this.name).error(this.message).trace(this.stack);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, StorageException);
+        }
+    }
+}

package/exceptions/index.d.ts

@@ -0,0 +1 @@
+export * from "../exceptions/StorageException";

package/exceptions/index.js

@@ -0,0 +1 @@
+export * from "../exceptions/StorageException";

package/facades/Storage.d.ts

@@ -0,0 +1,18 @@
+import type { Stats } from "fs";
+import type { StorageDisk, StorageOptions } from "../types/storage";
+import StorageBuilder from "../builders/StorageBuilder";
+export default class Storage {
+    static build(disk: StorageDisk): StorageBuilder;
+    static disk(disk: string): StorageBuilder;
+    static exists(path: string): Promise<boolean>;
+    static missing(path: string): Promise<boolean>;
+    static metadata(path: string): Promise<Stats | Bun.S3Stats>;
+    static size(path: string): Promise<number>;
+    static mimeType(path: string): Promise<string>;
+    static lastModified(path: string): Promise<Date>;
+    static get(path: string): Promise<Bun.BunFile | Bun.S3File>;
+    static put(path: string, content: any, options?: StorageOptions): Promise<void>;
+    static copy(source: string, destination: string, options?: StorageOptions): Promise<void>;
+    static move(source: string, destination: string, options?: StorageOptions): Promise<void>;
+    static delete(path: string): Promise<any>;
+}

package/facades/Storage.js

@@ -0,0 +1,42 @@
+import StorageBuilder from "../builders/StorageBuilder";
+export default class Storage {
+    static build(disk) {
+        return new StorageBuilder().build(disk);
+    }
+    static disk(disk) {
+        return new StorageBuilder().disk(disk);
+    }
+    static async exists(path) {
+        return await new StorageBuilder().exists(path);
+    }
+    static async missing(path) {
+        return await new StorageBuilder().missing(path);
+    }
+    static async metadata(path) {
+        return await new StorageBuilder().metadata(path);
+    }
+    static async size(path) {
+        return await new StorageBuilder().size(path);
+    }
+    static async mimeType(path) {
+        return await new StorageBuilder().mimeType(path);
+    }
+    static async lastModified(path) {
+        return await new StorageBuilder().lastModified(path);
+    }
+    static async get(path) {
+        return await new StorageBuilder().get(path);
+    }
+    static async put(path, content, options) {
+        return await new StorageBuilder().put(path, content);
+    }
+    static async copy(source, destination, options) {
+        return await new StorageBuilder().copy(source, destination, options);
+    }
+    static async move(source, destination, options) {
+        return await new StorageBuilder().move(source, destination, options);
+    }
+    static async delete(path) {
+        return await new StorageBuilder().delete(path);
+    }
+}

package/facades/index.d.ts

@@ -0,0 +1 @@
+export * from "../facades/Storage";

package/facades/index.js

@@ -0,0 +1 @@
+export * from "../facades/Storage";

package/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from "./facades/Storage";
+export * from "./enums/index";
+export * from "./facades/index";

package/index.js

@@ -0,0 +1,3 @@
+export { default } from "./facades/Storage";
+export * from "./enums/index";
+export * from "./facades/index";

package/package.json

@@ -0,0 +1,43 @@
+{
+    "name": "@bejibun/storage",
+    "version": "0.1.0",
+    "author": "Havea Crenata <havea.crenata@gmail.com>",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Bejibun-Framework/bejibun-storage.git"
+    },
+    "main": "index.js",
+    "module": "index.js",
+    "dependencies": {
+        "@bejibun/app": "^0.1.24",
+        "@bejibun/logger": "^0.1.22",
+        "@bejibun/utils": "^0.1.28"
+    },
+    "devDependencies": {
+        "@types/bun": "latest",
+        "tsc-alias": "^1.9.1"
+    },
+    "bugs": {
+        "url": "https://github.com/Bejibun-Framework/bejibun-storage/issues"
+    },
+    "description": "Storage for Bejibun Framework",
+    "homepage": "https://github.com/Bejibun-Framework/bejibun-storage#readme",
+    "keywords": [
+        "bun",
+        "bun framework",
+        "storage",
+        "bejibun",
+        "typescript"
+    ],
+    "license": "MIT",
+    "scripts": {
+        "alias": "bunx tsc-alias -p tsconfig.json",
+        "types": "cp -rf src/types dist",
+        "rsync": "rsync -a dist/ ./",
+        "clean": "rm -rf dist",
+        "build": "bunx tsc -p tsconfig.json && bun run types && bun run alias && bun run rsync && bun run clean",
+        "deploy": "bun run build && bun publish --access public"
+    },
+    "type": "module",
+    "types": "index.d.ts"
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "module": "ESNext",
+        "declaration": true,
+        "outDir": "dist",
+        "rootDir": "src",
+        "strict": true,
+        "moduleResolution": "bundler",
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "paths": {
+            "@/*": ["./src/*"]
+        },
+        "ignoreDeprecations": "6.0",
+        "types": ["bun-types"]
+    }
+}

package/types/index.d.ts

@@ -0,0 +1 @@
+export * from "../types/storage";

package/types/storage.d.ts

@@ -0,0 +1,138 @@
+import type {Stats} from "fs";
+
+export type StorageDisk = {
+    driver: string;
+    [key: string]: unknown;
+};
+
+export type StorageOptions = {
+    mode?: number;
+    createPath?: boolean;
+    acl?:
+        | "private"
+        | "public-read"
+        | "public-read-write"
+        | "aws-exec-read"
+        | "authenticated-read"
+        | "bucket-owner-read"
+        | "bucket-owner-full-control"
+        | "log-delivery-write";
+    bucket?: string;
+    region?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    sessionToken?: string;
+    endpoint?: string;
+    virtualHostedStyle?: boolean;
+    partSize?: number;
+    queueSize?: number;
+    retry?: number;
+    type?: string;
+    contentDisposition?: string | undefined;
+    storageClass?:
+        | "STANDARD"
+        | "DEEP_ARCHIVE"
+        | "EXPRESS_ONEZONE"
+        | "GLACIER"
+        | "GLACIER_IR"
+        | "INTELLIGENT_TIERING"
+        | "ONEZONE_IA"
+        | "OUTPOSTS"
+        | "REDUCED_REDUNDANCY"
+        | "SNOW"
+        | "STANDARD_IA";
+    requestPayer?: boolean;
+    highWaterMark?: number;
+};
+
+export interface StorageDriver {
+    /**
+     * Determine whether a file exists.
+     *
+     * @param filepath The path to the file.
+     * @returns True if the file exists; otherwise false.
+     */
+    exists(filepath: string): Promise<boolean>;
+
+    /**
+     * Determine whether a file is missing.
+     *
+     * @param filepath The path to the file.
+     * @returns True if the file does not exist; otherwise false.
+     */
+    missing(filepath: string): Promise<boolean>;
+
+    /**
+     * Retrieve metadata for a file.
+     *
+     * @param filepath The path to the file.
+     * @returns File metadata and statistics.
+     */
+    metadata(filepath: string): Promise<Stats | Bun.S3Stats>;
+
+    /**
+     * Get the file size in bytes.
+     *
+     * @param filepath The path to the file.
+     * @returns The file size in bytes.
+     */
+    size(filepath: string): Promise<number>;
+
+    /**
+     * Get the file MIME type.
+     *
+     * @param filepath The path to the file.
+     * @returns The detected MIME type.
+     */
+    mimeType(filepath: string): Promise<string>;
+
+    /**
+     * Get the file's last modification date.
+     *
+     * @param filepath The path to the file.
+     * @returns The last modified timestamp.
+     */
+    lastModified(filepath: string): Promise<Date>;
+
+    /**
+     * Retrieve a file from storage.
+     *
+     * @param filepath The path to the file.
+     * @returns The storage file instance.
+     */
+    get(filepath: string): Promise<Bun.BunFile | Bun.S3File>;
+
+    /**
+     * Store content at the given path.
+     *
+     * @param filepath The destination file path.
+     * @param content The content to store.
+     * @param options Additional storage options.
+     */
+    put(filepath: string, content: any, options?: StorageOptions): Promise<void>;
+
+    /**
+     * Copy a file to a new location.
+     *
+     * @param source The source file path.
+     * @param destination The destination file path.
+     * @param options Additional storage options.
+     */
+    copy(source: string, destination: string, options?: StorageOptions): Promise<void>;
+
+    /**
+     * Move a file to a new location.
+     *
+     * @param source The source file path.
+     * @param destination The destination file path.
+     * @param options Additional storage options.
+     */
+    move(source: string, destination: string, options?: StorageOptions): Promise<void>;
+
+    /**
+     * Delete a file from storage.
+     *
+     * @param filepath The path to the file.
+     */
+    delete(filepath: string): Promise<void>;
+}