@webtypen/webframez-core 0.1.15 → 0.1.17

package/dist/Facades/Storage.d.ts

@@ -0,0 +1,143 @@
+/// <reference types="node" />
+import { BaseStorageDriver, StorageDeleteOptions, StorageMkdirOptions, StorageReadDirOptions } from "./StorageDrivers/BaseStorageDriver";
+declare class StorageDriverRegistyFacade {
+    drivers: {
+        [key: string]: any;
+    };
+    constructor();
+}
+export declare const StorageDriverRegisty: StorageDriverRegistyFacade;
+declare class StorageFileInstance {
+    driver: BaseStorageDriver;
+    filepath: string;
+    constructor(filepath: string, driver: any);
+    exists(): Promise<boolean>;
+    isDir(): Promise<boolean>;
+    isFile(): Promise<boolean>;
+    delete(options?: StorageDeleteOptions): Promise<{
+        status: string;
+        filepath: string | string[];
+        payload?: any;
+    }>;
+    extension(options?: StorageDeleteOptions): Promise<{
+        status: string;
+        filepath: string | string[];
+        payload?: any;
+    }>;
+    mime(): Promise<string | null>;
+}
+declare class StorageDisk {
+    diskKey: string;
+    config: any;
+    driver: BaseStorageDriver;
+    constructor(key: string);
+    generateUploadFilepath(): string;
+    put(contents: string | Buffer, filepath?: string): Promise<{
+        status: string;
+        filepath: string;
+        payload?: any;
+    }>;
+    copy(filepath: string, target: string): Promise<{
+        status: string;
+        filepath: string;
+        origin_path: string;
+        payload?: any;
+    }>;
+    move(filepath: string, target: string): Promise<{
+        status: string;
+        filepath: string;
+        old_filepath: string;
+        payload?: any;
+    }>;
+    delete(filepath: string | string[], options?: StorageDeleteOptions): Promise<{
+        status: string;
+        filepath: string | string[];
+        payload?: any;
+    }>;
+    mkdir(filepath: string, options?: StorageMkdirOptions): Promise<{
+        status: string;
+        dirpath: string;
+        payload?: any;
+    }>;
+    isDir(filepath: string): Promise<{
+        status: string;
+        dirpath: string;
+        payload?: any;
+    }>;
+    isFile(filepath: string): Promise<{
+        status: string;
+        dirpath: string;
+        payload?: any;
+    }>;
+    file(filepath: string): Promise<StorageFileInstance>;
+    readDir(dirpath: string, options: StorageReadDirOptions): Promise<any[]>;
+}
+declare class StorageFacade {
+    disks: {
+        [key: string]: StorageDisk;
+    };
+    drivers: {
+        [key: string]: any;
+    };
+    disk(diskKey?: string): StorageDisk;
+    put(contents: string | Buffer, filepath?: string): Promise<{
+        status: string;
+        filepath: string;
+        payload?: any;
+    }>;
+    copy(filepath: string, target: string): Promise<{
+        status: string;
+        filepath: string;
+        origin_path: string;
+        payload?: any;
+    }>;
+    move(filepath: string, target: string): Promise<{
+        status: string;
+        filepath: string;
+        old_filepath: string;
+        payload?: any;
+    }>;
+    delete(filepath: string | string[], options: StorageDeleteOptions): Promise<{
+        status: string;
+        filepath: string | string[];
+        payload?: any;
+    }>;
+    mkdir(filepath: string, options: StorageMkdirOptions): Promise<{
+        status: string;
+        dirpath: string;
+        payload?: any;
+    }>;
+    isDir(filepath: string): Promise<{
+        status: string;
+        dirpath: string;
+        payload?: any;
+    }>;
+    isFile(filepath: string): Promise<{
+        status: string;
+        dirpath: string;
+        payload?: any;
+    }>;
+    file(filepath: string): Promise<StorageFileInstance>;
+    readDir(dirpath: string, options: StorageReadDirOptions): Promise<any[]>;
+}
+declare class StorageFileFacade {
+    storage: StorageFacade;
+    constructor(storage: StorageFacade);
+    exists(filepath: string, diskKey?: string): Promise<boolean>;
+    isDir(filepath: string, diskKey?: string): Promise<boolean>;
+    isFile(filepath: string, diskKey?: string): Promise<boolean>;
+    delete(filepath: string, options?: StorageDeleteOptions, diskKey?: string): Promise<{
+        status: string;
+        filepath: string | string[];
+        payload?: any;
+    }>;
+    extension(filepath: string, diskKey?: string): Promise<{
+        status: string;
+        filepath: string | string[];
+        payload?: any;
+    }>;
+    mime(filepath: string, diskKey?: string): Promise<string | null>;
+}
+export declare const Storage: StorageFacade;
+export declare const StorageFile: StorageFileFacade;
+export {};

package/dist/Facades/Storage.js

@@ -0,0 +1,238 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageFile = exports.Storage = exports.StorageDriverRegisty = void 0;
+const path_1 = __importDefault(require("path"));
+const Config_1 = require("../Config");
+const LocalStorageDriver_1 = require("./StorageDrivers/LocalStorageDriver");
+const StringFunctions_1 = require("../Functions/StringFunctions");
+class StorageDriverRegistyFacade {
+    constructor() {
+        this.drivers = {};
+        this.drivers.local = LocalStorageDriver_1.LocalStorageDriver;
+    }
+}
+exports.StorageDriverRegisty = new StorageDriverRegistyFacade();
+class StorageFileInstance {
+    constructor(filepath, driver) {
+        this.driver = driver;
+        this.filepath = filepath;
+    }
+    exists() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.driver.exists(this.filepath);
+        });
+    }
+    isDir() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.driver.isDir(this.filepath);
+        });
+    }
+    isFile() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.driver.isFile(this.filepath);
+        });
+    }
+    delete(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.driver.delete(this.filepath, options);
+        });
+    }
+    extension(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.driver.delete(this.filepath, options);
+        });
+    }
+    mime() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.driver.mime(this.filepath);
+        });
+    }
+}
+class StorageDisk {
+    constructor(key) {
+        this.diskKey = key;
+        this.config = Config_1.Config.get("storage.storages." + this.diskKey);
+        if (!this.config.driver) {
+            throw new Error(`[STORAGE ERROR] Missing driver for disk '${this.diskKey}'.`);
+        }
+        if (!exports.StorageDriverRegisty || !exports.StorageDriverRegisty.drivers || !exports.StorageDriverRegisty.drivers[this.config.driver]) {
+            throw new Error(`[STORAGE ERROR] Invalid driver '${this.config.driver}' for disk '${this.diskKey}'.`);
+        }
+        this.driver = new exports.StorageDriverRegisty.drivers[this.config.driver](this.config);
+    }
+    generateUploadFilepath() {
+        const date = new Date();
+        return path_1.default.join(this.config.uploadsDir && this.config.uploadsDir.trim() !== "" ? this.config.uploadsDir : "uploads", date.getFullYear().toString(), date.getMonth().toString() + "-" + date.getDate().toString(), date.valueOf().toString() + "_" + StringFunctions_1.StringFunctions.random(24));
+    }
+    put(contents, filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.driver)
+                throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+            return yield this.driver.put(filepath && filepath.trim() !== "" ? filepath : this.generateUploadFilepath(), contents);
+        });
+    }
+    copy(filepath, target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.driver)
+                throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+            return yield this.driver.copy(filepath, target);
+        });
+    }
+    move(filepath, target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.driver)
+                throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+            return yield this.driver.move(filepath, target);
+        });
+    }
+    delete(filepath, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.driver)
+                throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+            return yield this.driver.delete(filepath, options);
+        });
+    }
+    mkdir(filepath, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.driver)
+                throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+            return yield this.driver.mkdir(filepath, options);
+        });
+    }
+    isDir(filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.driver)
+                throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+            return yield this.driver.mkdir(filepath);
+        });
+    }
+    isFile(filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.driver)
+                throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+            return yield this.driver.mkdir(filepath);
+        });
+    }
+    file(filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.driver)
+                throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+            return new StorageFileInstance(filepath, this.driver);
+        });
+    }
+    readDir(dirpath, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.driver)
+                throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+            return yield this.driver.readDir(dirpath, options);
+        });
+    }
+}
+class StorageFacade {
+    constructor() {
+        this.disks = {};
+        this.drivers = {};
+    }
+    disk(diskKey) {
+        const key = diskKey !== null && diskKey !== void 0 ? diskKey : Config_1.Config.get("storage.defaultStorage");
+        if (this.disks[key]) {
+            return this.disks[key];
+        }
+        this.disks[key] = new StorageDisk(key);
+        return this.disks[key];
+    }
+    put(contents, filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.disk().put(contents, filepath);
+        });
+    }
+    copy(filepath, target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.disk().copy(filepath, target);
+        });
+    }
+    move(filepath, target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.disk().move(filepath, target);
+        });
+    }
+    delete(filepath, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.disk().delete(filepath, options);
+        });
+    }
+    mkdir(filepath, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.disk().mkdir(filepath, options);
+        });
+    }
+    isDir(filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.disk().isDir(filepath);
+        });
+    }
+    isFile(filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.disk().isFile(filepath);
+        });
+    }
+    file(filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.disk().file(filepath);
+        });
+    }
+    readDir(dirpath, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.disk().readDir(dirpath, options);
+        });
+    }
+}
+class StorageFileFacade {
+    constructor(storage) {
+        this.storage = storage;
+    }
+    exists(filepath, diskKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new StorageFileInstance(filepath, this.storage.disk(diskKey)).exists();
+        });
+    }
+    isDir(filepath, diskKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new StorageFileInstance(filepath, this.storage.disk(diskKey)).isDir();
+        });
+    }
+    isFile(filepath, diskKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new StorageFileInstance(filepath, this.storage.disk(diskKey)).isFile();
+        });
+    }
+    delete(filepath, options, diskKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new StorageFileInstance(filepath, this.storage.disk(diskKey)).delete(options);
+        });
+    }
+    extension(filepath, diskKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new StorageFileInstance(filepath, this.storage.disk(diskKey)).extension();
+        });
+    }
+    mime(filepath, diskKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new StorageFileInstance(filepath, this.storage.disk(diskKey)).mime();
+        });
+    }
+}
+exports.Storage = new StorageFacade();
+exports.StorageFile = new StorageFileFacade(exports.Storage);

package/dist/Facades/StorageDrivers/BaseStorageDriver.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+export type StorageDeleteOptions = {
+    recursive?: boolean;
+    force?: boolean;
+};
+export type StorageMkdirOptions = {
+    recursive?: boolean;
+};
+export type StorageReadDirOptions = {
+    onyFiles?: boolean;
+    onlyDirs?: boolean;
+};
+export interface BaseStorageDriver {
+    put(filepath: string, contents: string | Buffer): Promise<{
+        status: string;
+        filepath: string;
+        payload?: any;
+    }>;
+    copy(filepath: string, target: string): Promise<{
+        status: string;
+        filepath: string;
+        origin_path: string;
+        payload?: any;
+    }>;
+    move(filepath: string, target: string): Promise<{
+        status: string;
+        filepath: string;
+        old_filepath: string;
+        payload?: any;
+    }>;
+    delete(filepath: string | string[], options?: StorageDeleteOptions): Promise<{
+        status: string;
+        filepath: string | string[];
+        payload?: any;
+    }>;
+    mkdir(dirpath: string, options?: StorageMkdirOptions): Promise<{
+        status: string;
+        dirpath: string;
+        payload?: any;
+    }>;
+    exists(filepath: string): Promise<boolean>;
+    isDir(dirpath: string): Promise<boolean>;
+    isFile(filepath: string): Promise<boolean>;
+    extension(filepath: string): Promise<string | null>;
+    mime(filepath: string): Promise<string | null>;
+    readDir(dirpath: string, options?: StorageReadDirOptions): Promise<any[]>;
+}

package/dist/Facades/StorageDrivers/BaseStorageDriver.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Facades/StorageDrivers/LocalStorageDriver.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+import { BaseStorageDriver, StorageDeleteOptions, StorageMkdirOptions, StorageReadDirOptions } from "./BaseStorageDriver";
+export declare class LocalStorageDriver implements BaseStorageDriver {
+    config: any;
+    basepath: string;
+    constructor(conf: any);
+    path(...args: string[]): string;
+    put(filepath: string, contents: string | Buffer): Promise<{
+        status: string;
+        filepath: string;
+        payload: {};
+    }>;
+    copy(filepath: string, target: string): Promise<{
+        status: string;
+        filepath: string;
+        origin_path: string;
+        payload: {};
+    }>;
+    move(filepath: string, target: string): Promise<{
+        status: string;
+        filepath: string;
+        old_filepath: string;
+        payload: {};
+    }>;
+    delete(filepath: string | string[], options?: StorageDeleteOptions): Promise<{
+        status: string;
+        filepath: string | string[];
+        payload: {};
+    }>;
+    mkdir(dirpath: string, options?: StorageMkdirOptions): Promise<{
+        status: string;
+        dirpath: string;
+        payload: {};
+    }>;
+    exists(filepath: string): Promise<boolean>;
+    isDir(dirpath: string): Promise<boolean>;
+    isFile(filepath: string): Promise<boolean>;
+    extension(filepath: string): Promise<string | null>;
+    mime(filepath: string): Promise<string | null>;
+    readDir(dirpath: string, options?: StorageReadDirOptions): Promise<string[]>;
+}

package/dist/Facades/StorageDrivers/LocalStorageDriver.js

@@ -0,0 +1,128 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStorageDriver = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const mime_types_1 = __importDefault(require("mime-types"));
+const FileFunctions_1 = require("../../Functions/FileFunctions");
+class LocalStorageDriver {
+    constructor(conf) {
+        this.config = conf;
+        this.basepath = conf.basepath && conf.basepath.trim() !== "" ? conf.basepath : (0, FileFunctions_1.storageDir)();
+    }
+    path(...args) {
+        return path_1.default.join(this.basepath, ...args);
+    }
+    put(filepath, contents) {
+        return __awaiter(this, void 0, void 0, function* () {
+            fs_1.default.writeFileSync(this.path(filepath), contents);
+            return {
+                status: "success",
+                filepath: filepath,
+                payload: {},
+            };
+        });
+    }
+    copy(filepath, target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            fs_1.default.cpSync(this.path(filepath), target);
+            return {
+                status: "success",
+                filepath: target,
+                origin_path: filepath,
+                payload: {},
+            };
+        });
+    }
+    move(filepath, target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            fs_1.default.renameSync(this.path(filepath), target);
+            return {
+                status: "success",
+                filepath: target,
+                old_filepath: filepath,
+                payload: {},
+            };
+        });
+    }
+    delete(filepath, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Array.isArray(filepath)) {
+                for (let el of filepath) {
+                    if (options === null || options === void 0 ? void 0 : options.recursive) {
+                        fs_1.default.rmSync(this.path(el), { recursive: true, force: options.force ? true : false });
+                    }
+                    else {
+                        fs_1.default.rmSync(this.path(el), { recursive: true, force: (options === null || options === void 0 ? void 0 : options.force) ? true : false });
+                    }
+                }
+            }
+            else {
+                fs_1.default.rmSync(this.path(filepath), { recursive: (options === null || options === void 0 ? void 0 : options.recursive) ? true : false, force: (options === null || options === void 0 ? void 0 : options.force) ? true : false });
+            }
+            return {
+                status: "success",
+                filepath: filepath,
+                payload: {},
+            };
+        });
+    }
+    mkdir(dirpath, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            fs_1.default.mkdirSync(this.path(dirpath));
+            return {
+                status: "success",
+                dirpath: dirpath,
+                payload: {},
+            };
+        });
+    }
+    exists(filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return fs_1.default.existsSync(this.path(filepath));
+        });
+    }
+    isDir(dirpath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stats = fs_1.default.lstatSync(this.path(dirpath));
+            return stats.isDirectory();
+        });
+    }
+    isFile(filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stats = fs_1.default.lstatSync(this.path(filepath));
+            return stats.isFile();
+        });
+    }
+    extension(filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const temp = filepath.indexOf(".") > 0 ? filepath.substring(filepath.lastIndexOf(".") + 1) : null;
+            return temp && temp.trim() !== "" ? temp.trim() : null;
+        });
+    }
+    mime(filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const temp = mime_types_1.default.lookup(this.path(filepath));
+            return temp ? temp : null;
+        });
+    }
+    readDir(dirpath, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entries = fs_1.default.readdirSync(this.path(dirpath));
+            return entries && entries.length > 0 ? entries : [];
+        });
+    }
+}
+exports.LocalStorageDriver = LocalStorageDriver;

package/dist/index.d.ts

@@ -18,3 +18,5 @@ export * from "./Router/Response";
 export * from "./Database/BaseDBDriver";
 export * from "./Database/DBDrivers";
 export * from "./Database/QueryBuilder";
+export * from "./Facades/StorageDrivers/BaseStorageDriver";
+export * from "./Facades/Storage";

package/dist/index.js

@@ -34,3 +34,5 @@ __exportStar(require("./Router/Response"), exports);
 __exportStar(require("./Database/BaseDBDriver"), exports);
 __exportStar(require("./Database/DBDrivers"), exports);
 __exportStar(require("./Database/QueryBuilder"), exports);
+__exportStar(require("./Facades/StorageDrivers/BaseStorageDriver"), exports);
+__exportStar(require("./Facades/Storage"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webtypen/webframez-core",
-    "version": "0.1.15",
+    "version": "0.1.17",
     "description": "The core package of the typescript based webframez (web-framework) by webtypen.de",
     "homepage": "https://webtypen.de/",
     "license": "MIT",

package/src/Config.ts

@@ -1,37 +1,37 @@
 import lodash from "lodash";
 
 type ConfigType = {
-  key: string;
-  component: any;
+    key: string;
+    component: any;
 };
 
 class ConfigFacade {
-  configs: { [key: string]: any } = {};
+    configs: { [key: string]: any } = {};
 
-  register(key: string | ConfigType[], component: { [key: string]: any }) {
-    if (typeof key === "string") {
-      this.configs[key] = component;
-    } else if (Array.isArray(key)) {
-      for (let conf of key) {
-        if (!conf.key || !conf.component) {
-          continue;
+    register(key: string | ConfigType[], component: { [key: string]: any }) {
+        if (typeof key === "string") {
+            this.configs[key] = component;
+        } else if (Array.isArray(key)) {
+            for (let conf of key) {
+                if (!conf.key || !conf.component) {
+                    continue;
+                }
+                this.configs[conf.key] = conf.component;
+            }
         }
-        this.configs[conf.key] = conf.component;
-      }
+        return this;
     }
-    return this;
-  }
 
-  get(key: string) {
-    return lodash.get(this.configs, key);
-  }
+    get(key: string) {
+        return lodash.get(this.configs, key);
+    }
 
-  set(path: string, value: any | null | undefined) {
-    const newConfig = { ...this.configs };
-    lodash.set(newConfig, path, value);
-    this.configs = newConfig;
-    return this;
-  }
+    set(path: string, value: any | null | undefined) {
+        const newConfig = { ...this.configs };
+        lodash.set(newConfig, path, value);
+        this.configs = newConfig;
+        return this;
+    }
 }
 
 export const Config = new ConfigFacade();

package/src/Facades/Storage.ts

@@ -0,0 +1,208 @@
+import path from "path";
+import { Config } from "../Config";
+import { BaseStorageDriver, StorageDeleteOptions, StorageMkdirOptions, StorageReadDirOptions } from "./StorageDrivers/BaseStorageDriver";
+import { LocalStorageDriver } from "./StorageDrivers/LocalStorageDriver";
+import { StringFunctions } from "../Functions/StringFunctions";
+
+class StorageDriverRegistyFacade {
+    drivers: { [key: string]: any } = {};
+
+    constructor() {
+        this.drivers.local = LocalStorageDriver;
+    }
+}
+export const StorageDriverRegisty = new StorageDriverRegistyFacade();
+
+class StorageFileInstance {
+    driver: BaseStorageDriver;
+    filepath: string;
+
+    constructor(filepath: string, driver: any) {
+        this.driver = driver;
+        this.filepath = filepath;
+    }
+
+    async exists() {
+        return this.driver.exists(this.filepath);
+    }
+
+    async isDir() {
+        return this.driver.isDir(this.filepath);
+    }
+
+    async isFile() {
+        return this.driver.isFile(this.filepath);
+    }
+
+    async delete(options?: StorageDeleteOptions) {
+        return this.driver.delete(this.filepath, options);
+    }
+
+    async extension(options?: StorageDeleteOptions) {
+        return this.driver.delete(this.filepath, options);
+    }
+
+    async mime() {
+        return this.driver.mime(this.filepath);
+    }
+}
+
+class StorageDisk {
+    diskKey: string;
+    config: any;
+    driver: BaseStorageDriver;
+
+    constructor(key: string) {
+        this.diskKey = key;
+        this.config = Config.get("storage.storages." + this.diskKey);
+        if (!this.config.driver) {
+            throw new Error(`[STORAGE ERROR] Missing driver for disk '${this.diskKey}'.`);
+        }
+
+        if (!StorageDriverRegisty || !StorageDriverRegisty.drivers || !StorageDriverRegisty.drivers[this.config.driver]) {
+            throw new Error(`[STORAGE ERROR] Invalid driver '${this.config.driver}' for disk '${this.diskKey}'.`);
+        }
+        this.driver = new StorageDriverRegisty.drivers[this.config.driver](this.config);
+    }
+
+    generateUploadFilepath() {
+        const date = new Date();
+        return path.join(
+            this.config.uploadsDir && this.config.uploadsDir.trim() !== "" ? this.config.uploadsDir : "uploads",
+            date.getFullYear().toString(),
+            date.getMonth().toString() + "-" + date.getDate().toString(),
+            date.valueOf().toString() + "_" + StringFunctions.random(24)
+        );
+    }
+
+    async put(contents: string | Buffer, filepath?: string) {
+        if (!this.driver) throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+        return await this.driver.put(filepath && filepath.trim() !== "" ? filepath : this.generateUploadFilepath(), contents);
+    }
+
+    async copy(filepath: string, target: string) {
+        if (!this.driver) throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+        return await this.driver.copy(filepath, target);
+    }
+
+    async move(filepath: string, target: string) {
+        if (!this.driver) throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+        return await this.driver.move(filepath, target);
+    }
+
+    async delete(filepath: string | string[], options?: StorageDeleteOptions) {
+        if (!this.driver) throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+        return await this.driver.delete(filepath, options);
+    }
+
+    async mkdir(filepath: string, options?: StorageMkdirOptions) {
+        if (!this.driver) throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+        return await this.driver.mkdir(filepath, options);
+    }
+
+    async isDir(filepath: string) {
+        if (!this.driver) throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+        return await this.driver.mkdir(filepath);
+    }
+
+    async isFile(filepath: string) {
+        if (!this.driver) throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+        return await this.driver.mkdir(filepath);
+    }
+
+    async file(filepath: string) {
+        if (!this.driver) throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+        return new StorageFileInstance(filepath, this.driver);
+    }
+
+    async readDir(dirpath: string, options: StorageReadDirOptions) {
+        if (!this.driver) throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
+        return await this.driver.readDir(dirpath, options);
+    }
+}
+
+class StorageFacade {
+    disks: { [key: string]: StorageDisk } = {};
+    drivers: { [key: string]: any } = {};
+
+    disk(diskKey?: string) {
+        const key = diskKey ?? Config.get("storage.defaultStorage");
+        if (this.disks[key]) {
+            return this.disks[key];
+        }
+
+        this.disks[key] = new StorageDisk(key);
+        return this.disks[key];
+    }
+
+    async put(contents: string | Buffer, filepath?: string) {
+        return await this.disk().put(contents, filepath);
+    }
+
+    async copy(filepath: string, target: string) {
+        return await this.disk().copy(filepath, target);
+    }
+
+    async move(filepath: string, target: string) {
+        return await this.disk().move(filepath, target);
+    }
+
+    async delete(filepath: string | string[], options: StorageDeleteOptions) {
+        return await this.disk().delete(filepath, options);
+    }
+
+    async mkdir(filepath: string, options: StorageMkdirOptions) {
+        return await this.disk().mkdir(filepath, options);
+    }
+
+    async isDir(filepath: string) {
+        return await this.disk().isDir(filepath);
+    }
+
+    async isFile(filepath: string) {
+        return await this.disk().isFile(filepath);
+    }
+
+    async file(filepath: string) {
+        return await this.disk().file(filepath);
+    }
+
+    async readDir(dirpath: string, options: StorageReadDirOptions) {
+        return await this.disk().readDir(dirpath, options);
+    }
+}
+
+class StorageFileFacade {
+    storage: StorageFacade;
+
+    constructor(storage: StorageFacade) {
+        this.storage = storage;
+    }
+
+    async exists(filepath: string, diskKey?: string) {
+        return new StorageFileInstance(filepath, this.storage.disk(diskKey)).exists();
+    }
+
+    async isDir(filepath: string, diskKey?: string) {
+        return new StorageFileInstance(filepath, this.storage.disk(diskKey)).isDir();
+    }
+
+    async isFile(filepath: string, diskKey?: string) {
+        return new StorageFileInstance(filepath, this.storage.disk(diskKey)).isFile();
+    }
+
+    async delete(filepath: string, options?: StorageDeleteOptions, diskKey?: string) {
+        return new StorageFileInstance(filepath, this.storage.disk(diskKey)).delete(options);
+    }
+
+    async extension(filepath: string, diskKey?: string) {
+        return new StorageFileInstance(filepath, this.storage.disk(diskKey)).extension();
+    }
+
+    async mime(filepath: string, diskKey?: string) {
+        return new StorageFileInstance(filepath, this.storage.disk(diskKey)).mime();
+    }
+}
+
+export const Storage = new StorageFacade();
+export const StorageFile = new StorageFileFacade(Storage);

package/src/Facades/StorageDrivers/BaseStorageDriver.ts

@@ -0,0 +1,30 @@
+export type StorageDeleteOptions = {
+    recursive?: boolean;
+    force?: boolean;
+};
+
+export type StorageMkdirOptions = {
+    recursive?: boolean;
+};
+
+export type StorageReadDirOptions = {
+    onyFiles?: boolean;
+    onlyDirs?: boolean;
+};
+
+export interface BaseStorageDriver {
+    put(filepath: string, contents: string | Buffer): Promise<{ status: string; filepath: string; payload?: any }>;
+    copy(filepath: string, target: string): Promise<{ status: string; filepath: string; origin_path: string; payload?: any }>;
+    move(filepath: string, target: string): Promise<{ status: string; filepath: string; old_filepath: string; payload?: any }>;
+    delete(
+        filepath: string | string[],
+        options?: StorageDeleteOptions
+    ): Promise<{ status: string; filepath: string | string[]; payload?: any }>;
+    mkdir(dirpath: string, options?: StorageMkdirOptions): Promise<{ status: string; dirpath: string; payload?: any }>;
+    exists(filepath: string): Promise<boolean>;
+    isDir(dirpath: string): Promise<boolean>;
+    isFile(filepath: string): Promise<boolean>;
+    extension(filepath: string): Promise<string | null>;
+    mime(filepath: string): Promise<string | null>;
+    readDir(dirpath: string, options?: StorageReadDirOptions): Promise<any[]>;
+}

package/src/Facades/StorageDrivers/LocalStorageDriver.ts

@@ -0,0 +1,110 @@
+import fs from "fs";
+import path from "path";
+import mime from "mime-types";
+import { BaseStorageDriver, StorageDeleteOptions, StorageMkdirOptions, StorageReadDirOptions } from "./BaseStorageDriver";
+import { storageDir } from "../../Functions/FileFunctions";
+
+export class LocalStorageDriver implements BaseStorageDriver {
+    config: any;
+    basepath: string;
+
+    constructor(conf: any) {
+        this.config = conf;
+        this.basepath = conf.basepath && conf.basepath.trim() !== "" ? conf.basepath : storageDir();
+    }
+
+    path(...args: string[]) {
+        return path.join(this.basepath, ...args);
+    }
+
+    async put(filepath: string, contents: string | Buffer) {
+        fs.writeFileSync(this.path(filepath), contents);
+
+        return {
+            status: "success",
+            filepath: filepath,
+            payload: {},
+        };
+    }
+
+    async copy(filepath: string, target: string) {
+        fs.cpSync(this.path(filepath), target);
+
+        return {
+            status: "success",
+            filepath: target,
+            origin_path: filepath,
+            payload: {},
+        };
+    }
+
+    async move(filepath: string, target: string) {
+        fs.renameSync(this.path(filepath), target);
+
+        return {
+            status: "success",
+            filepath: target,
+            old_filepath: filepath,
+            payload: {},
+        };
+    }
+
+    async delete(filepath: string | string[], options?: StorageDeleteOptions) {
+        if (Array.isArray(filepath)) {
+            for (let el of filepath) {
+                if (options?.recursive) {
+                    fs.rmSync(this.path(el), { recursive: true, force: options.force ? true : false });
+                } else {
+                    fs.rmSync(this.path(el), { recursive: true, force: options?.force ? true : false });
+                }
+            }
+        } else {
+            fs.rmSync(this.path(filepath), { recursive: options?.recursive ? true : false, force: options?.force ? true : false });
+        }
+
+        return {
+            status: "success",
+            filepath: filepath,
+            payload: {},
+        };
+    }
+
+    async mkdir(dirpath: string, options?: StorageMkdirOptions) {
+        fs.mkdirSync(this.path(dirpath));
+
+        return {
+            status: "success",
+            dirpath: dirpath,
+            payload: {},
+        };
+    }
+
+    async exists(filepath: string) {
+        return fs.existsSync(this.path(filepath));
+    }
+
+    async isDir(dirpath: string) {
+        const stats = fs.lstatSync(this.path(dirpath));
+        return stats.isDirectory();
+    }
+
+    async isFile(filepath: string) {
+        const stats = fs.lstatSync(this.path(filepath));
+        return stats.isFile();
+    }
+
+    async extension(filepath: string) {
+        const temp = filepath.indexOf(".") > 0 ? filepath.substring(filepath.lastIndexOf(".") + 1) : null;
+        return temp && temp.trim() !== "" ? temp.trim() : null;
+    }
+
+    async mime(filepath: string) {
+        const temp = mime.lookup(this.path(filepath));
+        return temp ? temp : null;
+    }
+
+    async readDir(dirpath: string, options?: StorageReadDirOptions) {
+        const entries = fs.readdirSync(this.path(dirpath));
+        return entries && entries.length > 0 ? entries : [];
+    }
+}

package/src/Functions/StringFunctions.ts

@@ -1,47 +1,46 @@
 class StringFunctionsFacade {
-  slug(string: string) {
-    string = (string + "").toLowerCase();
-    string = string.replace(new RegExp("  ", "g"), " ");
-    string = string.replace(new RegExp("  ", "g"), " ");
-    string = string.replace(new RegExp(" ", "g"), "-");
-    string = string.replace(new RegExp("_", "g"), "-");
+    slug(string: string) {
+        string = (string + "").toLowerCase();
+        string = string.replace(new RegExp("  ", "g"), " ");
+        string = string.replace(new RegExp("  ", "g"), " ");
+        string = string.replace(new RegExp(" ", "g"), "-");
+        string = string.replace(new RegExp("_", "g"), "-");
 
-    const replacements: { [key: string]: string } = {
-      Ä: "AE",
-      ä: "ae",
-      Ö: "OE",
-      ö: "oe",
-      Ü: "UE",
-      ü: "ue",
-      Đ: "D",
-      đ: "d",
-      "&": "and",
-      "€": "euro",
-      "<": "less",
-      ">": "greater",
-    };
-    for (let i in replacements) {
-      string = string.replace(new RegExp(i, "g"), replacements[i]);
-    }
+        const replacements: { [key: string]: string } = {
+            Ä: "AE",
+            ä: "ae",
+            Ö: "OE",
+            ö: "oe",
+            Ü: "UE",
+            ü: "ue",
+            Đ: "D",
+            đ: "d",
+            "&": "and",
+            "€": "euro",
+            "<": "less",
+            ">": "greater",
+        };
+        for (let i in replacements) {
+            string = string.replace(new RegExp(i, "g"), replacements[i]);
+        }
 
-    return string.replace(/[^a-zA-Z0-9\- ]/g, "").trim();
-  }
+        return string.replace(/[^a-zA-Z0-9\- ]/g, "").trim();
+    }
 
-  random(length: number) {
-    const result = [];
-    const chars =
-      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-    for (let i = 0; i < length; i++) {
-      result.push(chars.charAt(Math.floor(Math.random() * chars.length)));
+    random(length: number) {
+        const result = [];
+        const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+        for (let i = 0; i < length; i++) {
+            result.push(chars.charAt(Math.floor(Math.random() * chars.length)));
+        }
+        return result.join("");
     }
-    return result.join("");
-  }
 
-  nl2br(str: string, replaceMode?: boolean, isXhtml?: boolean) {
-    const breakTag = isXhtml ? "<br />" : "<br>";
-    const replaceStr = replaceMode ? "$1" + breakTag : "$1" + breakTag + "$2";
-    return (str + "").replace(/([^>\r\n]?)(\r\n|\n\r|\r|\n)/g, replaceStr);
-  }
+    nl2br(str: string, replaceMode?: boolean, isXhtml?: boolean) {
+        const breakTag = isXhtml ? "<br />" : "<br>";
+        const replaceStr = replaceMode ? "$1" + breakTag : "$1" + breakTag + "$2";
+        return (str + "").replace(/([^>\r\n]?)(\r\n|\n\r|\r|\n)/g, replaceStr);
+    }
 }
 
 export const StringFunctions = new StringFunctionsFacade();

package/src/index.ts

@@ -18,3 +18,5 @@ export * from "./Router/Response";
 export * from "./Database/BaseDBDriver";
 export * from "./Database/DBDrivers";
 export * from "./Database/QueryBuilder";
+export * from "./Facades/StorageDrivers/BaseStorageDriver";
+export * from "./Facades/Storage";