@kidus.dev/flowdb 1.0.0

package/dist/core/collection/query/relation.js

@@ -0,0 +1,40 @@
+import Collection from "../collection";
+export default class Relation {
+    name;
+    localCollection;
+    localKey;
+    foreignCollection;
+    foreignKey;
+    type;
+    constructor(params) {
+        this.name = params.name;
+        this.localCollection = params.localCollection;
+        this.localKey = params.localKey;
+        this.foreignCollection = params.foreignCollection;
+        this.foreignKey = params.foreignKey;
+        this.type = params.type;
+    }
+    toJson() {
+        return {
+            name: this.name,
+            localCollection: this.localCollection,
+            localKey: this.localKey,
+            foreignCollection: this.foreignCollection,
+            foreignKey: this.foreignKey,
+            type: this.type,
+        };
+    }
+    static fromJson(json) {
+        return new Relation({
+            name: json.name,
+            localCollection: json.localCollection,
+            localKey: json.localKey,
+            foreignCollection: json.foreignCollection,
+            foreignKey: json.foreignKey,
+            type: json.type,
+        });
+    }
+    toString() {
+        return `Relation(name: ${this.name}, localCollection: ${this.localCollection}, localKey: ${this.localKey}, foreignCollection: ${this.foreignCollection}, foreignKey: ${this.foreignKey}, type: ${this.type})`;
+    }
+}

package/dist/core/database/backup.d.ts

@@ -0,0 +1,26 @@
+export default class Backup {
+    name: string;
+    databaseDirectory: string;
+    backupDirectory: string;
+    metaFile: string;
+    meta: {
+        [key: string]: any;
+    };
+    static getBackupsDirectory(databaseDirectory: string): string;
+    constructor({ databaseDirectory, name, }: {
+        databaseDirectory: string;
+        name: string;
+    });
+    get size(): number;
+    get sizeFormatted(): string;
+    create(): void;
+    static fromPath(p_: string): Backup;
+    static fromName(name: string, databaseDirectory: string): Backup;
+    static create({ databaseDirectory, name, }: {
+        databaseDirectory: string;
+        name: string;
+    }): Backup;
+    delete(): void;
+    toString(): string;
+}
+//# sourceMappingURL=backup.d.ts.map

package/dist/core/database/backup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backup.d.ts","sourceRoot":"","sources":["../../../src/core/database/backup.ts"],"names":[],"mappings":"AAIA,MAAM,CAAC,OAAO,OAAO,MAAM;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC;IAE7B,MAAM,CAAC,mBAAmB,CAAC,iBAAiB,EAAE,MAAM,GAAG,MAAM;gBAIjD,EACV,iBAAiB,EACjB,IAAI,GACL,EAAE;QACD,iBAAiB,EAAE,MAAM,CAAC;QAC1B,IAAI,EAAE,MAAM,CAAC;KACd;IAeD,IAAI,IAAI,IAAI,MAAM,CAajB;IAED,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,MAAM,IAAI,IAAI;IASd,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAOnC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,MAAM;IAIhE,MAAM,CAAC,MAAM,CAAC,EACZ,iBAAiB,EACjB,IAAI,GACL,EAAE;QACD,iBAAiB,EAAE,MAAM,CAAC;QAC1B,IAAI,EAAE,MAAM,CAAC;KACd,GAAG,MAAM;IAsCV,MAAM,IAAI,IAAI;IAmBd,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/core/database/backup.js

@@ -0,0 +1,114 @@
+import * as fs from "fs";
+import * as path from "path";
+import Format from "../../tools/format";
+export default class Backup {
+    name;
+    databaseDirectory;
+    backupDirectory;
+    metaFile;
+    meta;
+    static getBackupsDirectory(databaseDirectory) {
+        return path.join(databaseDirectory, "backups");
+    }
+    constructor({ databaseDirectory, name, }) {
+        this.name = name;
+        this.databaseDirectory = databaseDirectory;
+        this.backupDirectory = path.join(Backup.getBackupsDirectory(databaseDirectory), name);
+        this.metaFile = path.join(this.backupDirectory, "meta.json");
+        this.meta = {
+            database: this.databaseDirectory,
+            backup: this.backupDirectory,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    get size() {
+        if (!fs.existsSync(this.backupDirectory))
+            return 0;
+        const getSize = (dir) => fs.readdirSync(dir, { withFileTypes: true }).reduce((acc, entry) => {
+            const p = path.join(dir, entry.name);
+            if (entry.isFile()) {
+                return acc + fs.statSync(p).size;
+            }
+            else if (entry.isDirectory()) {
+                return acc + getSize(p);
+            }
+            return acc;
+        }, 0);
+        return getSize(this.backupDirectory);
+    }
+    get sizeFormatted() {
+        return Format.sizeToHumanReadable(this.size);
+    }
+    create() {
+        if (!fs.existsSync(this.backupDirectory))
+            fs.mkdirSync(this.backupDirectory, { recursive: true });
+        if (!fs.existsSync(this.metaFile)) {
+            fs.writeFileSync(this.metaFile, JSON.stringify(this.meta, null, 2));
+        }
+        this.meta = JSON.parse(fs.readFileSync(this.metaFile, "utf-8"));
+    }
+    static fromPath(p_) {
+        return new Backup({
+            name: path.basename(p_),
+            databaseDirectory: path.dirname(p_),
+        });
+    }
+    static fromName(name, databaseDirectory) {
+        return new Backup({ name, databaseDirectory });
+    }
+    static create({ databaseDirectory, name, }) {
+        const backup = Backup.fromName(name, databaseDirectory);
+        backup.create();
+        const walk = (dir) => {
+            let results = [];
+            for (const entry of fs.readdirSync(dir)) {
+                const p_ = path.join(dir, entry);
+                const stat = fs.statSync(p_);
+                if (p_.includes("backup") ||
+                    (stat.isDirectory() && path.basename(p_) === "backups")) {
+                    continue;
+                }
+                if (stat.isFile()) {
+                    results.push(p_);
+                }
+                else if (stat.isDirectory()) {
+                    results = results.concat(walk(p_));
+                }
+            }
+            return results;
+        };
+        const list = walk(databaseDirectory);
+        for (const file of list) {
+            const relativePath = path.relative(databaseDirectory, file);
+            const newPath = path.join(backup.backupDirectory, relativePath);
+            const dirName = path.dirname(newPath);
+            if (!fs.existsSync(dirName)) {
+                fs.mkdirSync(dirName, { recursive: true });
+            }
+            fs.copyFileSync(file, newPath);
+        }
+        return backup;
+    }
+    delete() {
+        if (fs.existsSync(this.backupDirectory)) {
+            const rmDir = (dirPath) => {
+                if (fs.existsSync(dirPath)) {
+                    for (const entry of fs.readdirSync(dirPath)) {
+                        const curPath = path.join(dirPath, entry);
+                        if (fs.lstatSync(curPath).isDirectory()) {
+                            rmDir(curPath);
+                        }
+                        else {
+                            fs.unlinkSync(curPath);
+                        }
+                    }
+                    fs.rmdirSync(dirPath);
+                }
+            };
+            rmDir(this.backupDirectory);
+        }
+    }
+    toString() {
+        return `Backup [ ${this.databaseDirectory} • ${this.name} • ${this.sizeFormatted} • ${this.meta["timestamp"]} ]`;
+    }
+}

package/dist/core/database/database.d.ts

@@ -0,0 +1,57 @@
+import Collection from "../collection/collection";
+import Store from "../store/store";
+import BlobStorage from "../blob/blob_storage";
+import Backup from "./backup";
+export interface DatabaseOptions {
+    path?: string;
+    encrypted?: boolean;
+    secretKey?: string;
+}
+export declare function openDatabase(name: string, options?: DatabaseOptions): Database;
+export default class Database {
+    readonly name: string;
+    private readonly _storage;
+    private readonly _encrypted;
+    private readonly _collections;
+    private readonly _stores;
+    private readonly _blobStorages;
+    constructor(name: string, { path, encrypted, secretKey }?: DatabaseOptions);
+    static open(name: string, options?: DatabaseOptions): Database;
+    get path(): string;
+    get encrypted(): boolean;
+    get size(): number;
+    get sizeFormatted(): string;
+    get collections(): Map<string, Collection>;
+    get stores(): Map<string, Store>;
+    get blobStorages(): Map<string, BlobStorage>;
+    collectionsList(options?: {
+        pick?: string[];
+        omit?: string[];
+    }): Collection[];
+    storesList(options?: {
+        pick?: string[];
+        omit?: string[];
+    }): Store[];
+    storeExists(name: string): boolean;
+    store(name: string): Store;
+    collectionExists(name: string): boolean;
+    collection(name: string): Collection;
+    blobStorageExists(name: string): boolean;
+    blobStorage(name: string, options?: {
+        chunksSize?: number;
+        encrypt?: boolean;
+        secretKey?: string;
+    }): BlobStorage;
+    get backups(): Backup[];
+    backup(name: string): Backup;
+    removeBackup(name: string): void;
+    removeAllBackups(): void;
+    reset(): void;
+    clear(): void;
+    drop(): void;
+    dropStore(storeName: string): void;
+    dropCollection(collectionName: string): void;
+    dropBlobStorage(blobStorageName: string): void;
+    toString(): string;
+}
+//# sourceMappingURL=database.d.ts.map

package/dist/core/database/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../src/core/database/database.ts"],"names":[],"mappings":"AAIA,OAAO,UAAU,MAAM,0BAA0B,CAAC;AAClD,OAAO,KAAK,MAAM,gBAAgB,CAAC;AACnC,OAAO,WAAW,MAAM,sBAAsB,CAAC;AAC/C,OAAO,MAAM,MAAM,UAAU,CAAC;AAG9B,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAGD,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,eAAoB,GAC5B,QAAQ,CAEV;AAED,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAU;IAErC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAsC;IACnE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiC;IACzD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAuC;gBAGnE,IAAI,EAAE,MAAM,EACZ,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,GAAE,eAAoB;IAmBtD,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,QAAQ;IAIlE,IAAI,IAAI,IAAI,MAAM,CAEjB;IACD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IACD,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,IAAI,WAAW,IAAI,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAEzC;IACD,IAAI,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAE/B;IACD,IAAI,YAAY,IAAI,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAE3C;IAED,eAAe,CAAC,OAAO,CAAC,EAAE;QACxB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;KACjB,GAAG,UAAU,EAAE;IAoBhB,UAAU,CAAC,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,KAAK,EAAE;IAqBnE,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAGlC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAc1B,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAGvC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAcpC,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAGxC,WAAW,CACT,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;QACP,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;KACf,GACL,WAAW;IAmBd,IAAI,OAAO,IAAI,MAAM,EAAE,CAEtB;IACD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAK5B,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAGhC,gBAAgB,IAAI,IAAI;IAKxB,KAAK,IAAI,IAAI;IAGb,KAAK,IAAI,IAAI;IAGb,IAAI,IAAI,IAAI;IAGZ,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAGlC,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAG5C,eAAe,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI;IAI9C,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/core/database/database.js

@@ -0,0 +1,179 @@
+// The following is a TypeScript port of the Database API from the Dart code.
+import { Format } from "../../tools";
+import { DatabaseFileDriver } from "./database_file_driver";
+import Collection from "../collection/collection";
+import Store from "../store/store";
+import BlobStorage from "../blob/blob_storage";
+import Backup from "./backup";
+// database factory function for convenience
+export function openDatabase(name, options = {}) {
+    return Database.open(name, options);
+}
+export default class Database {
+    name;
+    _storage;
+    _encrypted;
+    _collections = new Map();
+    _stores = new Map();
+    _blobStorages = new Map();
+    constructor(name, { path, encrypted, secretKey } = {}) {
+        this.name = name;
+        this._storage = new DatabaseFileDriver({
+            name,
+            dbPath: path ?? name,
+            encrypted: encrypted ?? false,
+        });
+        this._encrypted = encrypted ?? false;
+        // Add existing collections and stores
+        Object.entries(this._storage.getCollections() ?? {}).forEach(([k, v]) => this._collections.set(k, v));
+        Object.entries(this._storage.getStores?.() ?? {}).forEach(([k, v]) => this._stores.set(k, v));
+    }
+    static open(name, options = {}) {
+        return new Database(name, options);
+    }
+    get path() {
+        return this._storage.dbPath;
+    }
+    get encrypted() {
+        return this._encrypted;
+    }
+    get size() {
+        return this._storage.size;
+    }
+    get sizeFormatted() {
+        return Format.sizeToHumanReadable(this.size);
+    }
+    get collections() {
+        return this._collections;
+    }
+    get stores() {
+        return this._stores;
+    }
+    get blobStorages() {
+        return this._blobStorages;
+    }
+    collectionsList(options) {
+        const { pick, omit } = options || {};
+        if (pick && omit) {
+            throw new Error("pick and omit cannot be used together");
+        }
+        if (pick) {
+            return Array.from(this._collections.keys())
+                .filter((e) => pick.includes(e))
+                .map((e) => this._collections.get(e))
+                .filter(Boolean);
+        }
+        if (omit) {
+            return Array.from(this._collections.keys())
+                .filter((e) => !omit.includes(e))
+                .map((e) => this._collections.get(e))
+                .filter(Boolean);
+        }
+        return Array.from(this._collections.values());
+    }
+    storesList(options) {
+        const { pick, omit } = options || {};
+        if (pick && omit) {
+            throw new Error("pick and omit cannot be used together");
+        }
+        if (pick) {
+            return Array.from(this._stores.keys())
+                .filter((e) => pick.includes(e))
+                .map((e) => this._stores.get(e))
+                .filter(Boolean);
+        }
+        if (omit) {
+            return Array.from(this._stores.keys())
+                .filter((e) => !omit.includes(e))
+                .map((e) => this._stores.get(e))
+                .filter(Boolean);
+        }
+        return Array.from(this._stores.values());
+    }
+    //   STORES;
+    storeExists(name) {
+        return this._stores.has(name);
+    }
+    store(name) {
+        if (!this._stores.has(name)) {
+            const s = new Store({
+                name,
+                path: `${this.path}/stores/${name}`,
+                encrypted: this._encrypted,
+            });
+            s.create?.();
+            this._stores.set(name, s);
+        }
+        return this._stores.get(name);
+    }
+    // COLLECTIONS
+    collectionExists(name) {
+        return this._collections.has(name);
+    }
+    collection(name) {
+        if (!this._collections.has(name)) {
+            const c = new Collection({
+                name,
+                path: `${this.path}/collections/${name}`,
+                encrypted: this._encrypted,
+                database: this,
+            });
+            this._collections.set(name, c);
+        }
+        return this._collections.get(name);
+    }
+    // BLOBS
+    blobStorageExists(name) {
+        return this._blobStorages.has(name);
+    }
+    blobStorage(name, options = {}) {
+        const { chunksSize = 1024 * 512 /* 524288 */, encrypt, secretKey, } = options;
+        if (!this._blobStorages.has(name)) {
+            const bs = new BlobStorage({
+                name,
+                path: `${this.path}/blobs/${name}`,
+                chunksSize,
+                encrypted: this._encrypted,
+            });
+            this._blobStorages.set(name, bs);
+        }
+        return this._blobStorages.get(name);
+    }
+    // BACKUPS
+    get backups() {
+        return this._storage.getBackups();
+    }
+    backup(name) {
+        const backup = this._storage.backup(name);
+        backup.create();
+        return backup;
+    }
+    removeBackup(name) {
+        this._storage.removeBackup(name);
+    }
+    removeAllBackups() {
+        this._storage.removeAllBackups();
+    }
+    // RESET/CLEAR/DROP
+    reset() {
+        this._storage.reset();
+    }
+    clear() {
+        this.reset();
+    }
+    drop() {
+        this._storage.delete();
+    }
+    dropStore(storeName) {
+        this.store(storeName).drop();
+    }
+    dropCollection(collectionName) {
+        this.collection(collectionName).drop();
+    }
+    dropBlobStorage(blobStorageName) {
+        this.blobStorage(blobStorageName).clear();
+    }
+    toString() {
+        return `Database [ ${this.name} • ${this.sizeFormatted} • ${this.collections.size} collections ]`;
+    }
+}

package/dist/core/database/database_file_driver.d.ts

@@ -0,0 +1,27 @@
+import Collection from "../collection/collection";
+import Store from "../store/store";
+import Backup from "./backup";
+export declare class DatabaseFileDriver {
+    name: string;
+    dbPath: string;
+    directory: string;
+    encrypted: boolean;
+    constructor({ name, dbPath, encrypted, }: {
+        name: string;
+        dbPath: string;
+        encrypted: boolean;
+    });
+    get size(): number;
+    create(): void;
+    delete(): void;
+    reset(): void;
+    backup(backupName: string): Backup;
+    removeBackup(backupName: string): void;
+    removeAllBackups(): void;
+    getBackups(): Backup[];
+    getCollections(): Collection[];
+    getStores(): Record<string, Store>;
+    private _getDirectorySize;
+    private _copyRecursive;
+}
+//# sourceMappingURL=database_file_driver.d.ts.map

package/dist/core/database/database_file_driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database_file_driver.d.ts","sourceRoot":"","sources":["../../../src/core/database/database_file_driver.ts"],"names":[],"mappings":"AAGA,OAAO,UAAU,MAAM,0BAA0B,CAAC;AAClD,OAAO,KAAK,MAAM,gBAAgB,CAAC;AACnC,OAAO,MAAM,MAAM,UAAU,CAAC;AAE9B,qBAAa,kBAAkB;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;gBAEP,EACV,IAAI,EACJ,MAAM,EACN,SAAS,GACV,EAAE;QACD,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,OAAO,CAAC;KACpB;IAOD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,MAAM,IAAI,IAAI;IAKd,MAAM,IAAI,IAAI;IAKd,KAAK,IAAI,IAAI;IAKb,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAWlC,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAOtC,gBAAgB,IAAI,IAAI;IAOxB,UAAU,IAAI,MAAM,EAAE;IAetB,cAAc,IAAI,UAAU,EAAE;IAiB9B,SAAS,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAuBlC,OAAO,CAAC,iBAAiB;IAgBzB,OAAO,CAAC,cAAc;CAmBvB"}

package/dist/core/database/database_file_driver.js

@@ -0,0 +1,135 @@
+import * as fs from "fs";
+import * as path from "path";
+import Collection from "../collection/collection";
+import Store from "../store/store";
+import Backup from "./backup";
+export class DatabaseFileDriver {
+    name;
+    dbPath;
+    directory;
+    encrypted;
+    constructor({ name, dbPath, encrypted, }) {
+        this.name = name;
+        this.dbPath = dbPath;
+        this.directory = dbPath;
+        this.encrypted = encrypted;
+    }
+    get size() {
+        return this._getDirectorySize(this.directory);
+    }
+    create() {
+        if (!fs.existsSync(this.directory))
+            fs.mkdirSync(this.directory, { recursive: true });
+    }
+    delete() {
+        if (fs.existsSync(this.directory))
+            fs.rmSync(this.directory, { recursive: true, force: true });
+    }
+    reset() {
+        this.delete();
+        this.create();
+    }
+    backup(backupName) {
+        const backupDir = path.join(this.directory, "backups", backupName);
+        if (!fs.existsSync(backupDir))
+            fs.mkdirSync(backupDir, { recursive: true });
+        this._copyRecursive(this.directory, backupDir, ["backups"]);
+        return new Backup({
+            name: backupName,
+            databaseDirectory: this.directory,
+        });
+    }
+    removeBackup(backupName) {
+        const backupDir = path.join(this.directory, "backups", backupName);
+        if (fs.existsSync(backupDir)) {
+            fs.rmSync(backupDir, { recursive: true, force: true });
+        }
+    }
+    removeAllBackups() {
+        const backupsDir = path.join(this.directory, "backups");
+        if (fs.existsSync(backupsDir)) {
+            fs.rmSync(backupsDir, { recursive: true, force: true });
+        }
+    }
+    getBackups() {
+        const backupsDir = path.join(this.directory, "backups");
+        if (!fs.existsSync(backupsDir))
+            return [];
+        return fs
+            .readdirSync(backupsDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => new Backup({
+            name: entry.name,
+            databaseDirectory: this.directory,
+        }));
+    }
+    getCollections() {
+        const collectionsDir = path.join(this.directory, "collections");
+        if (!fs.existsSync(collectionsDir))
+            return [];
+        return fs
+            .readdirSync(collectionsDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => new Collection({
+            name: entry.name,
+            path: path.join(collectionsDir, entry.name),
+            encrypted: this.encrypted,
+            database: this,
+        }));
+    }
+    getStores() {
+        const storesDir = path.join(this.directory, "stores");
+        if (!fs.existsSync(storesDir))
+            return {};
+        return fs
+            .readdirSync(storesDir, { withFileTypes: true })
+            .filter((entry) => entry.isFile())
+            .reduce((acc, entry) => {
+            const name = entry.name;
+            const s = new Store({
+                name,
+                path: path.join(storesDir, name),
+                encrypted: this.encrypted,
+            });
+            s.create?.();
+            return acc;
+        }, {});
+    }
+    // --- Internal helpers ---
+    _getDirectorySize(dir) {
+        let total = 0;
+        if (!fs.existsSync(dir))
+            return 0;
+        const list = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of list) {
+            const entryPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                total += this._getDirectorySize(entryPath);
+            }
+            else if (entry.isFile()) {
+                total += fs.statSync(entryPath).size;
+            }
+        }
+        return total;
+    }
+    // Copy contents of the src directory to dest directory, skipping any folders named in excludeDirs.
+    _copyRecursive(src, dest, excludeDirs = []) {
+        if (!fs.existsSync(src))
+            return;
+        if (!fs.existsSync(dest))
+            fs.mkdirSync(dest, { recursive: true });
+        const items = fs.readdirSync(src, { withFileTypes: true });
+        for (const item of items) {
+            if (excludeDirs.includes(item.name))
+                continue;
+            const srcPath = path.join(src, item.name);
+            const destPath = path.join(dest, item.name);
+            if (item.isDirectory()) {
+                this._copyRecursive(srcPath, destPath, excludeDirs);
+            }
+            else if (item.isFile()) {
+                fs.copyFileSync(srcPath, destPath);
+            }
+        }
+    }
+}

package/dist/core/store/store.d.ts

@@ -0,0 +1,24 @@
+export default class Store {
+    private _name;
+    private _storage;
+    constructor({ name, path, encrypted, secretKey, }: {
+        name: string;
+        path: string;
+        encrypted?: boolean;
+        secretKey?: string;
+    });
+    get name(): string;
+    create(): void;
+    set(key: string, value: any): any;
+    setFrom(key: string, func: (data: any) => any, fallback?: any): any;
+    has(key: string): boolean;
+    get(key: string): any;
+    remove(key: string): any;
+    all(): any;
+    clear(): any;
+    drop(): void;
+    get size(): number;
+    get sizeFormatted(): string;
+    toString(): string;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/core/store/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/core/store/store.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO,OAAO,KAAK;IACxB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAkB;gBAEtB,EACV,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,GACV,EAAE;QACD,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB;IASD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,MAAM,IAAI,IAAI;IAId,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG;IAIjC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,GAAG,EAAE,QAAQ,CAAC,EAAE,GAAG,GAAG,GAAG;IAInE,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG;IAIrB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG;IAIxB,GAAG,IAAI,GAAG;IAIV,KAAK,IAAI,GAAG;IAIZ,IAAI,IAAI,IAAI;IAKZ,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/core/store/store.js

@@ -0,0 +1,54 @@
+import { Format } from "../../tools";
+import StoreFileDriver from "./store_file_driver";
+export default class Store {
+    _name;
+    _storage;
+    constructor({ name, path, encrypted, secretKey, }) {
+        this._name = name;
+        this._storage = new StoreFileDriver({
+            secretKey,
+            path,
+            encrypted,
+        });
+    }
+    get name() {
+        return this._name;
+    }
+    create() {
+        this._storage.create();
+    }
+    set(key, value) {
+        return this._storage.set(key, value);
+    }
+    setFrom(key, func, fallback) {
+        return this._storage.setFrom(key, func, fallback);
+    }
+    has(key) {
+        return this._storage.has(key);
+    }
+    get(key) {
+        return this._storage.get(key);
+    }
+    remove(key) {
+        return this._storage.remove(key);
+    }
+    all() {
+        return this._storage.readAll();
+    }
+    clear() {
+        return this._storage.clear();
+    }
+    drop() {
+        this._storage.delete();
+    }
+    // INFO
+    get size() {
+        return this._storage.size;
+    }
+    get sizeFormatted() {
+        return Format.sizeToHumanReadable(this.size);
+    }
+    toString() {
+        return `Store [ ${this._name} • ${this.sizeFormatted} • ${Object.keys(this.all()).length} keys ]`;
+    }
+}