@bejibun/core 0.1.62 → 0.1.64

package/CHANGELOG.md

@@ -3,6 +3,70 @@ All notable changes to this project will be documented in this file.
 
 ---
 
+## [v0.1.64](https://github.com/crenata/bejibun-core/compare/v0.1.61...v0.1.64) - 2025-12-25
+
+### 🩹 Fixes
+
+### 📖 Changes
+#### What's New :
+#### Storage
+A filesystem facade, with built-in disk management including disks configuration and build disk at runtime.
+
+- 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.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").delete("path/to/your/file.ext");
+```
+
+- New Disk at Runtime
+```ts
+import Storage from "@bejibun/core/facades/Storage";
+
+await Storage.build({
+    driver: "local", // "local" | DiskDriverEnum.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")
+}).delete("path/to/your/file.ext");
+```
+
+### ❤️Contributors
+- Havea Crenata ([@crenata](https://github.com/crenata))
+
+**Full Changelog**: https://github.com/crenata/bejibun-core/blob/master/CHANGELOG.md
+
+---
+
 ## [v0.1.61](https://github.com/crenata/bejibun-core/compare/v0.1.58...v0.1.61) - 2025-12-12
 
 ### 🩹 Fixes

package/README.md

@@ -22,6 +22,557 @@ Install the package.
 bun add @bejibun/core
 ```
 
+### Available Commands
+To see list of available commands, run.
+
+```bash
+bun ace
+bun ace help
+bun ace --h
+bun ace --help
+```
+
+To see help of specific command, run :
+
+```bash
+bun ace help migrate:latest
+bun ace migrate:latest --h
+bun ace migrate:latest --help
+```
+
+### Database
+
+#### Migrations
+To fresh or drop all table and re-run the migrations, run :
+
+```bash
+bun ace migrate:fresh
+```
+
+Example :
+
+```bash
+This will DROP ALL tables and re-run ALL migrations. Are you want to continue? (Y/N): Y
+
+✔ Rolled back all migrations
+✔ Batch 1 finished
+✔ 20250929_000001_tests.ts
+```
+
+To migrate the migrations, run :
+
+```bash
+bun ace migrate:latest
+```
+
+Example :
+
+```bash
+✔ Batch 1 finished
+✔ 20250929_000001_tests.ts
+```
+
+To rollback the migrations, run :
+
+```bash
+bun ace migrate:rollback
+```
+
+Example :
+
+```bash
+This will ROLLBACK latest migrations. Are you want to continue? (Y/N): Y
+
+✔ Batch 1 finished
+✔ 20250929_000001_tests.ts
+```
+
+To see migrations status, run :
+
+```bash
+bun ace migrate:status
+```
+
+Example :
+
+```bash
+✔ Completed Migrations :
+✔ No migrations were completed.
+
+✔ Pending Migrations :
+✔ 20250929_000001_tests.ts
+```
+
+#### Seeders
+To execute seeder, run :
+
+```bash
+bun ace db:seed
+```
+
+Example :
+
+```bash
+✔ Seeding finished
+✔ 20250929_000001_seeder_test.ts
+```
+
+## Features
+
+### Controllers
+Logical processes
+
+Example :
+
+```ts
+import BaseController from "@bejibun/core/bases/BaseController";
+
+export default class HelloController extends BaseController {
+    public async hello(request: Bun.BunRequest): Promise<Response> {
+        return super.response.setData({
+            message: "Hello, world!",
+            method: request.method
+        }).send();
+    }
+}
+```
+
+### Exception Handler
+Handle any incoming errors
+
+Example :
+
+```ts
+import ExceptionHandler from "@bejibun/core/exceptions/ExceptionHandler";
+
+export default class Handler extends ExceptionHandler {
+    public handle(error: any): globalThis.Response {
+        // Your code goes here
+        return super.handle(error);
+    }
+}
+```
+
+### Middlewares
+Handle any request before forwarding to controller
+
+Example :
+
+```ts
+import type {HandlerType} from "@bejibun/core/types";
+import Logger from "@bejibun/logger";
+
+export default class TestMiddleware {
+    public handle(handler: HandlerType): HandlerType {
+        return async (request: Bun.BunRequest) => {
+            Logger.setContext("TestMiddleware").debug(request.url);
+
+            return handler(request);
+        };
+    }
+}
+```
+
+Usage :
+
+```ts
+import Router from "@bejibun/core/facades/Router";
+import TestMiddleware from "@/app/middlewares/TestMiddleware";
+import LoggerMiddleware from "@/app/middlewares/LoggerMiddleware";
+
+export default Router.prefix("test")
+    .middleware(
+        new TestMiddleware(),
+        new LoggerMiddleware()
+    )
+    .group([
+        Router.get("redis", "TestController@redis"),
+        Router.get("get", "TestController@get"),
+        Router.get("detail/:id", "TestController@detail"),
+        Router.post("add", "TestController@add"),
+        Router.post("edit", "TestController@edit"),
+        Router.delete("delete/:id", "TestController@delete"),
+        Router.get("restore/:id", "TestController@restore")
+    ]);
+```
+
+### Validators
+Validate any incoming requests
+
+Example :
+
+```ts
+import type {ValidatorType} from "@bejibun/core/types/ValidatorType";
+import BaseValidator from "@bejibun/core/bases/BaseValidator";
+import TestModel from "@/app/models/TestModel";
+
+export default class TestValidator extends BaseValidator {
+    public static get detail(): ValidatorType {
+        return super.validator.compile(
+            super.validator.object({
+                id: super.validator.number().min(1).exists(TestModel, "id")
+            })
+        );
+    }
+
+    public static get add(): ValidatorType {
+        return super.validator.compile(
+            super.validator.object({
+                name: super.validator.string()
+            })
+        );
+    }
+
+    public static get edit(): ValidatorType {
+        return super.validator.compile(
+            super.validator.object({
+                id: super.validator.number().min(1).exists(TestModel, "id"),
+                name: super.validator.string()
+            })
+        );
+    }
+
+    public static get delete(): ValidatorType {
+        return super.validator.compile(
+            super.validator.object({
+                id: super.validator.number().min(1).exists(TestModel, "id")
+            })
+        );
+    }
+
+    public static get restore(): ValidatorType {
+        return super.validator.compile(
+            super.validator.object({
+                id: super.validator.number().min(1).exists(TestModel, "id", true)
+            })
+        );
+    }
+}
+```
+
+Usage :
+
+```ts
+import BaseController from "@bejibun/core/bases/BaseController";
+import TestModel from "@/app/models/TestModel";
+import TestValidator from "@/app/validators/TestValidator";
+
+export default class TestController extends BaseController {
+    public async detail(request: Bun.BunRequest): Promise<Response> {
+        const body = await super.parse(request);
+        await super.validate(TestValidator.detail, body);
+
+        const test = await TestModel.findOrFail(body.id as number | string);
+
+        return super.response.setData(test).send();
+    }
+}
+```
+
+### Models
+Database table model
+
+Example :
+
+```ts
+import BaseModel, {BaseColumns} from "@bejibun/core/bases/BaseModel";
+import {DateTime} from "luxon";
+
+export interface TestColumns extends BaseColumns {
+    name: string;
+}
+
+export default class TestModel extends BaseModel implements TestColumns {
+    public static tableName: string = "tests";
+    public static idColumn: string = "id";
+
+    declare id: bigint;
+    declare name: string;
+    declare created_at: DateTime | string;
+    declare updated_at: DateTime | string;
+    declare deleted_at: DateTime | string | null;
+}
+```
+
+#### Fetch All
+Example :
+
+```ts
+import BaseController from "@bejibun/core/bases/BaseController";
+import TestModel from "@/app/models/TestModel";
+
+export default class TestController extends BaseController {
+    public async get(request: Bun.BunRequest): Promise<Response> {
+        const tests = await TestModel.all();
+
+        return super.response.setData(tests).send();
+    }
+}
+```
+
+#### Find or Fail
+Example :
+
+```ts
+import BaseController from "@bejibun/core/bases/BaseController";
+import TestModel from "@/app/models/TestModel";
+import TestValidator from "@/app/validators/TestValidator";
+
+export default class TestController extends BaseController {
+    public async detail(request: Bun.BunRequest): Promise<Response> {
+        const body = await super.parse(request);
+        await super.validate(TestValidator.detail, body);
+
+        const test = await TestModel.findOrFail(body.id as number | string);
+
+        return super.response.setData(test).send();
+    }
+}
+```
+
+#### Create
+Example :
+
+```ts
+import BaseController from "@bejibun/core/bases/BaseController";
+import TestModel from "@/app/models/TestModel";
+import TestValidator from "@/app/validators/TestValidator";
+
+export default class TestController extends BaseController {
+    public async add(request: Bun.BunRequest): Promise<Response> {
+        const body = await super.parse(request);
+        await super.validate(TestValidator.add, body);
+
+        const tests = await TestModel.create({
+            name: body.name as string
+        });
+
+        return super.response.setData(tests).send();
+    }
+}
+```
+
+#### Update
+Example :
+
+```ts
+import BaseController from "@bejibun/core/bases/BaseController";
+import TestModel from "@/app/models/TestModel";
+import TestValidator from "@/app/validators/TestValidator";
+
+export default class TestController extends BaseController {
+    public async edit(request: Bun.BunRequest): Promise<Response> {
+        const body = await super.parse(request);
+        await super.validate(TestValidator.edit, body);
+
+        const tests = await TestModel.find(body.id as number | string)
+            .update({
+                name: body.name as string
+            });
+
+        return super.response.setData(tests).send();
+    }
+}
+```
+
+#### Soft Delete
+Example :
+
+```ts
+import BaseController from "@bejibun/core/bases/BaseController";
+import TestModel from "@/app/models/TestModel";
+import TestValidator from "@/app/validators/TestValidator";
+
+export default class TestController extends BaseController {
+    public async delete(request: Bun.BunRequest): Promise<Response> {
+        const body = await super.parse(request);
+        await super.validate(TestValidator.delete, body);
+
+        const tests = await TestModel.find(body.id as number | string).delete();
+
+        return super.response.setData(tests).send();
+    }
+}
+```
+
+#### Force Delete
+Example :
+
+```ts
+import BaseController from "@bejibun/core/bases/BaseController";
+import TestModel from "@/app/models/TestModel";
+import TestValidator from "@/app/validators/TestValidator";
+
+export default class TestController extends BaseController {
+    public async delete(request: Bun.BunRequest): Promise<Response> {
+        const body = await super.parse(request);
+        await super.validate(TestValidator.delete, body);
+
+        const tests = await TestModel.find(body.id as number | string).forceDelete();
+
+        return super.response.setData(tests).send();
+    }
+}
+```
+
+#### With Trashed
+Example :
+
+```ts
+import BaseController from "@bejibun/core/bases/BaseController";
+import TestModel from "@/app/models/TestModel";
+
+export default class TestController extends BaseController {
+    public async get(request: Bun.BunRequest): Promise<Response> {
+        const tests = await TestModel.withTrashed();
+
+        return super.response.setData(tests).send();
+    }
+}
+```
+
+#### Only Trashed
+Example :
+
+```ts
+import BaseController from "@bejibun/core/bases/BaseController";
+import TestModel from "@/app/models/TestModel";
+
+export default class TestController extends BaseController {
+    public async get(request: Bun.BunRequest): Promise<Response> {
+        const tests = await TestModel.onlyTrashed();
+
+        return super.response.setData(tests).send();
+    }
+}
+```
+
+#### Restore
+Example :
+
+```ts
+import BaseController from "@bejibun/core/bases/BaseController";
+import TestModel from "@/app/models/TestModel";
+
+export default class TestController extends BaseController {
+    public async restore(request: Bun.BunRequest): Promise<Response> {
+        const body = await super.parse(request);
+        await super.validate(TestValidator.restore, body);
+
+        const tests = await TestModel.find(body.id as number | string).restore();
+
+        return super.response.setData(tests).send();
+    }
+}
+```
+
+### Database
+
+#### Migrations
+Example :
+
+```ts
+import type {Knex} from "knex";
+import TestModel from "@/app/models/TestModel";
+
+export function up(knex: Knex): void {
+    return knex.schema.createTable(TestModel.table, (table: Knex.TableBuilder) => {
+        table.bigIncrements("id");
+        table.string("name");
+        table.timestamps(true, true);
+        table.timestamp("deleted_at");
+    });
+}
+
+export function down(knex: Knex): void {
+    return knex.schema.dropTable(TestModel.table);
+}
+```
+
+#### Seeders
+Example :
+
+```ts
+import type {Knex} from "knex";
+import TestModel from "@/app/models/TestModel";
+
+export async function seed(knex: Knex): Promise<void> {
+    for (const name of ["Name 1", "Name 2", "Name 3"]) {
+        await TestModel.query(knex).insert({
+            name: name
+        });
+    }
+}
+```
+
+### Bootstrap
+Any startup loads
+
+```ts
+import Database from "@bejibun/database";
+import {Model} from "objection";
+import BaseModel from "@/bases/BaseModel";
+
+(BaseModel as any as typeof Model).knex(Database.knex());
+```
+
+### Storage
+A filesystem facade, with built-in disk management including disks configuration and build disk at runtime.
+
+- 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.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").delete("path/to/your/file.ext");
+```
+
+- New Disk at Runtime
+```ts
+import Storage from "@bejibun/core/facades/Storage";
+
+await Storage.build({
+    driver: "local", // "local" | DiskDriverEnum.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")
+}).delete("path/to/your/file.ext");
+```
+
+### Cors
+Documentation : [@bejibun/cors](https://github.com/crenata/bejibun-cors/blob/master/README.md)
+
+### Cache
+Documentation : [@bejibun/cache](https://github.com/crenata/bejibun-cache/blob/master/README.md)
+
 ### Ace
 Any commands for development
 
@@ -61,24 +612,6 @@ Examples:
   $ bun ace migrate:latest
 ```
 
-### Available Commands
-To see list of available commands, run.
-
-```bash
-bun ace
-bun ace help
-bun ace --h
-bun ace --help
-```
-
-To see help of specific command, run :
-
-```bash
-bun ace help migrate:latest
-bun ace migrate:latest --h
-bun ace migrate:latest --help
-```
-
 ## Contributors
 - [Havea Crenata](mailto:havea.crenata@gmail.com)
 

package/builders/StorageBuilder.d.ts

@@ -1,10 +1,17 @@
+import { StorageDisk } from "../types/storage";
 export default class StorageBuilder {
-    protected file: any;
-    protected directory?: string;
-    protected name?: string;
+    protected conf: Record<string, any>;
+    protected overrideDisk?: StorageDisk;
+    protected drive?: string;
     constructor();
-    setFile(file: any): StorageBuilder;
-    setDirectory(directory: string): StorageBuilder;
-    setName(name: string): StorageBuilder;
-    save(): Promise<any>;
+    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>;
+    get(filepath: string): Promise<any>;
+    put(filepath: string, content: any): Promise<void>;
+    delete(filepath: string): Promise<void>;
 }

package/builders/StorageBuilder.js

@@ -1,31 +1,112 @@
 import App from "@bejibun/app";
-import { isEmpty } from "@bejibun/utils";
-import Luxon from "@bejibun/utils/facades/Luxon";
-import Str from "@bejibun/utils/facades/Str";
+import Logger from "@bejibun/logger";
+import { defineValue, isEmpty } from "@bejibun/utils";
+import Enum from "@bejibun/utils/facades/Enum";
 import path from "path";
+import fs from "fs";
+import DiskConfig from "../config/disk";
+import DiskException from "../exceptions/DiskException";
+import DiskDriverEnum from "../enums/DiskDriverEnum";
 export default class StorageBuilder {
-    file;
-    directory;
-    name;
+    conf;
+    overrideDisk;
+    drive;
     constructor() {
-        this.name = "";
-        this.directory = "general";
+        const configPath = App.Path.configPath("disk.ts");
+        let config;
+        if (fs.existsSync(configPath))
+            config = require(configPath).default;
+        else
+            config = DiskConfig;
+        this.conf = config;
     }
-    setFile(file) {
-        this.file = file;
-        return this;
+    get config() {
+        if (isEmpty(this.conf))
+            throw new DiskException("There is no config provided.");
+        return this.conf;
+    }
+    get currentDisk() {
+        return defineValue(this.overrideDisk, this.config.disks[defineValue(this.drive, this.config.default)]);
     }
-    setDirectory(directory) {
-        this.directory = directory;
+    get driver() {
+        const driver = defineValue(this.currentDisk?.driver);
+        if (isEmpty(driver))
+            throw new DiskException(`Missing "driver" on disk config.`);
+        if (!Enum.setEnums(DiskDriverEnum).hasValue(driver))
+            throw new DiskException(`Not supported "driver" disk.`);
+        switch (driver) {
+            case DiskDriverEnum.Local:
+                if (isEmpty(this.currentDisk?.root))
+                    throw new DiskException(`Missing "root" for "local" disk configuration.`);
+                break;
+            default:
+                break;
+        }
+        return driver;
+    }
+    build(overrideDisk) {
+        this.overrideDisk = overrideDisk;
         return this;
     }
-    setName(name) {
-        this.name = name;
+    disk(drive) {
+        this.drive = drive;
         return this;
     }
-    async save() {
-        if (isEmpty(this.name))
-            this.name = Str.random();
-        await Bun.write(App.Path.storagePath(`app/public/${this.directory}/${Luxon.DateTime.now().toUnixInteger()}-${this.name}${path.extname(this.file?.name)}`), this.file);
+    async exists(filepath) {
+        if (isEmpty(filepath))
+            throw new DiskException("The file path is required.");
+        switch (this.driver) {
+            case DiskDriverEnum.Local:
+                return await Bun.file(path.resolve(this.currentDisk.root, filepath)).exists();
+            default:
+                return false;
+        }
+    }
+    async missing(filepath) {
+        if (isEmpty(filepath))
+            throw new DiskException("The file path is required.");
+        return !await this.exists(filepath);
+    }
+    async get(filepath) {
+        if (isEmpty(filepath))
+            throw new DiskException("The file path is required.");
+        let data = null;
+        switch (this.driver) {
+            case DiskDriverEnum.Local:
+                data = await Bun.file(path.resolve(this.currentDisk.root, filepath)).text();
+                break;
+            default:
+                break;
+        }
+        return data;
+    }
+    async put(filepath, content) {
+        if (isEmpty(filepath))
+            throw new DiskException("The file path is required.");
+        if (isEmpty(content))
+            throw new DiskException("The content is required.");
+        try {
+            switch (this.driver) {
+                case DiskDriverEnum.Local:
+                    await Bun.write(path.resolve(this.currentDisk.root, filepath), content);
+                    break;
+                default:
+                    break;
+            }
+        }
+        catch (error) {
+            Logger.setContext("Storage").error("Something went wrong when saving file.").trace(error);
+        }
+    }
+    async delete(filepath) {
+        if (isEmpty(filepath))
+            throw new DiskException("The file path is required.");
+        switch (this.driver) {
+            case DiskDriverEnum.Local:
+                await Bun.file(path.resolve(this.currentDisk.root, filepath)).delete();
+                break;
+            default:
+                break;
+        }
     }
 }

package/config/disk.d.ts

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

package/config/disk.js

@@ -0,0 +1,17 @@
+import App from "@bejibun/app";
+import DiskDriverEnum from "../enums/DiskDriverEnum";
+const config = {
+    default: "local",
+    disks: {
+        local: {
+            driver: DiskDriverEnum.Local,
+            root: App.Path.storagePath("app")
+        },
+        public: {
+            driver: DiskDriverEnum.Local,
+            root: App.Path.storagePath("app/public"),
+            url: `${Bun.env.APP_URL}/storage/public`
+        }
+    }
+};
+export default config;

package/enums/DiskDriverEnum.d.ts

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

package/enums/DiskDriverEnum.js

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

package/enums/index.d.ts

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

package/enums/index.js

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

package/exceptions/DiskException.d.ts

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

package/exceptions/DiskException.js

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

package/facades/Storage.d.ts

@@ -1,3 +1,11 @@
+import StorageBuilder from "../builders/StorageBuilder";
+import { StorageDisk } from "../types/storage";
 export default class Storage {
-    static save(file: any, directory?: string, name?: string): Promise<any>;
+    static build(disk: StorageDisk): StorageBuilder;
+    static disk(disk: string): StorageBuilder;
+    static exists(path: string): Promise<boolean>;
+    static missing(path: string): Promise<boolean>;
+    static get(path: string): Promise<any>;
+    static put(path: string, content: any): Promise<void>;
+    static delete(path: string): Promise<any>;
 }

package/facades/Storage.js

@@ -1,12 +1,24 @@
-import { isNotEmpty } from "@bejibun/utils";
 import StorageBuilder from "../builders/StorageBuilder";
 export default class Storage {
-    static async save(file, directory, name) {
-        const builder = new StorageBuilder().setFile(file);
-        if (isNotEmpty(directory))
-            builder.setDirectory(directory);
-        if (isNotEmpty(name))
-            builder.setName(name);
-        return await builder.save();
+    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 get(path) {
+        return await new StorageBuilder().get(path);
+    }
+    static async put(path, content) {
+        return await new StorageBuilder().put(path, content);
+    }
+    static async delete(path) {
+        return await new StorageBuilder().delete(path);
     }
 }

package/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./bases/index";
+export * from "./enums/index";
 export * from "./exceptions/index";
 export * from "./facades/index";
 export * from "./middlewares/index";

package/index.js

@@ -1,4 +1,5 @@
 export * from "./bases/index";
+export * from "./enums/index";
 export * from "./exceptions/index";
 export * from "./facades/index";
 export * from "./middlewares/index";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bejibun/core",
-    "version": "0.1.62",
+    "version": "0.1.64",
     "author": "Havea Crenata <havea.crenata@gmail.com>",
     "repository": {
         "type": "git",
@@ -10,7 +10,7 @@
     "module": "index.js",
     "dependencies": {
         "@bejibun/app": "^0.1.22",
-        "@bejibun/cache": "^0.1.16",
+        "@bejibun/cache": "^0.1.18",
         "@bejibun/cors": "^0.1.16",
         "@bejibun/database": "^0.1.19",
         "@bejibun/logger": "^0.1.22",

package/types/index.d.ts

@@ -1,4 +1,5 @@
 export * from "../types/middleware";
 export * from "../types/router";
+export * from "../types/storage";
 export * from "../types/validator";
 export * from "../types/vine";

package/types/storage.d.ts

@@ -0,0 +1,4 @@
+export type StorageDisk = {
+    driver: string,
+    [key: string]: unknown
+};