@kidus.dev/flowdb 1.0.0

package/README.md

@@ -0,0 +1,15 @@
+# flowdb
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.5. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/dist/core/blob/blob.d.ts

@@ -0,0 +1,25 @@
+import type Document from "../collection/document";
+import { BlobDiskDriver } from "./blob_disk_driver";
+export default class Blob {
+    private _id;
+    private _metadata?;
+    private _chunks?;
+    private _blobDiskDriver;
+    constructor(opts: {
+        id: string;
+        blobDiskDriver: BlobDiskDriver;
+        metadata?: Document;
+        chunks?: Buffer;
+    });
+    get id(): string;
+    get metadata(): Document | undefined;
+    get chunks(): Buffer | null;
+    getBytes(): Promise<Buffer | null>;
+    get bytesSync(): Buffer | null;
+    get bytesAsStream(): AsyncGenerator<Buffer | null>;
+    get size(): number;
+    get sizeAsHumanReadable(): string;
+    private formatSize;
+    toString(): string;
+}
+//# sourceMappingURL=blob.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blob.d.ts","sourceRoot":"","sources":["../../../src/core/blob/blob.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,IAAI;IACvB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,SAAS,CAAC,CAAW;IAC7B,OAAO,CAAC,OAAO,CAAC,CAAS;IACzB,OAAO,CAAC,eAAe,CAAiB;gBAE5B,IAAI,EAAE;QAChB,EAAE,EAAE,MAAM,CAAC;QACX,cAAc,EAAE,cAAc,CAAC;QAC/B,QAAQ,CAAC,EAAE,QAAQ,CAAC;QACpB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB;IAOD,IAAI,EAAE,IAAI,MAAM,CAEf;IACD,IAAI,QAAQ,IAAI,QAAQ,GAAG,SAAS,CAEnC;IACD,IAAI,MAAM,IAAI,MAAM,GAAG,IAAI,CAE1B;IAEK,QAAQ,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAGxC,IAAI,SAAS,IAAI,MAAM,GAAG,IAAI,CAE7B;IACD,IAAI,aAAa,IAAI,cAAc,CAAC,MAAM,GAAG,IAAI,CAAC,CAEjD;IACD,IAAI,IAAI,IAAI,MAAM,CAEjB;IACD,IAAI,mBAAmB,IAAI,MAAM,CAEhC;IAED,OAAO,CAAC,UAAU;IAWlB,QAAQ,IAAI,MAAM;CASnB"}

package/dist/core/blob/blob.js

@@ -0,0 +1,57 @@
+import { BlobDiskDriver } from "./blob_disk_driver";
+export default class Blob {
+    _id;
+    _metadata;
+    _chunks;
+    _blobDiskDriver;
+    constructor(opts) {
+        this._id = opts.id;
+        this._metadata = opts.metadata;
+        this._blobDiskDriver = opts.blobDiskDriver;
+        this._chunks = opts.chunks;
+    }
+    get id() {
+        return this._id;
+    }
+    get metadata() {
+        return this._metadata;
+    }
+    get chunks() {
+        return this._chunks ?? this.bytesSync;
+    }
+    async getBytes() {
+        return await this._blobDiskDriver.mergeChunks(this.id);
+    }
+    get bytesSync() {
+        return this._blobDiskDriver.mergeChunksSync(this.id);
+    }
+    get bytesAsStream() {
+        return this._blobDiskDriver.mergeChunksAsStream(this.id);
+    }
+    get size() {
+        return this._blobDiskDriver.getFileSize(this.id);
+    }
+    get sizeAsHumanReadable() {
+        return this.formatSize(this.size);
+    }
+    formatSize(bytes) {
+        if (bytes < 1024)
+            return `${bytes} B`;
+        const units = ["KB", "MB", "GB", "TB"];
+        let i = -1;
+        do {
+            bytes = bytes / 1024;
+            i++;
+        } while (bytes >= 1024 && i < units.length - 1);
+        return `${bytes.toFixed(2)} ${units[i]}`;
+    }
+    toString() {
+        return `
+Blob { 
+  id: ${this._id}, 
+  metadata: ${JSON.stringify(this._metadata)}, 
+  size: ${this.size} (${this.sizeAsHumanReadable})
+  length: ${(this.bytesSync && this.bytesSync.length) || 0}
+}`;
+    }
+}

package/dist/core/blob/blob_disk_driver.d.ts

@@ -0,0 +1,27 @@
+export declare class BlobDiskDriver {
+    private _directory;
+    encrypted: boolean;
+    constructor(directoryPath: string, encrypted: boolean);
+    create(): Promise<void>;
+    createSync(): void;
+    destroy(force?: boolean): Promise<void>;
+    destroySync(force?: boolean): void;
+    add(bytes: Buffer, fileId: string, chunkSize: number): Promise<Buffer>;
+    addSync(bytes: Buffer, fileId: string, chunkSize: number): Buffer;
+    mergeChunks(fileId: string): Promise<Buffer | null>;
+    mergeChunksSync(fileId: string): Buffer | null;
+    mergeChunksAsStream(fileId: string): AsyncGenerator<Buffer | null>;
+    private _chunkIndexFromPath;
+    getFileSize(fileId: string): number;
+    updateChunks(fileId: string, bytes: Buffer, chunkSize: number): Promise<Buffer | null>;
+    updateChunksSync(fileId: string, bytes: Buffer, chunkSize: number): Buffer | null;
+    deleteChunks(fileId: string): Promise<void>;
+    deleteChunksSync(fileId: string): void;
+    exists(fileId: string): Promise<boolean>;
+    existsSync(fileId: string): boolean;
+    getCount(): Promise<number>;
+    getCountSync(): number;
+    getSize(): Promise<number>;
+    getSizeSync(): number;
+}
+//# sourceMappingURL=blob_disk_driver.d.ts.map

package/dist/core/blob/blob_disk_driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob_disk_driver.d.ts","sourceRoot":"","sources":["../../../src/core/blob/blob_disk_driver.ts"],"names":[],"mappings":"AAGA,qBAAa,cAAc;IACzB,OAAO,CAAC,UAAU,CAAS;IACpB,SAAS,EAAE,OAAO,CAAC;gBAEd,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO;IAK/C,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAI7B,UAAU,IAAI,IAAI;IAIZ,OAAO,CAAC,KAAK,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBpD,WAAW,CAAC,KAAK,GAAE,OAAe,GAAG,IAAI;IAiBnC,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAa5E,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM;IAa3D,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAgBzD,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAgBvC,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAAC,MAAM,GAAG,IAAI,CAAC;IAezE,OAAO,CAAC,mBAAmB;IAM3B,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAU7B,YAAY,CAChB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAMzB,gBAAgB,CACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,IAAI;IAMV,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMjD,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAMhC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAO9C,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAQ7B,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC;IAIjC,YAAY,IAAI,MAAM;IAIhB,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAchC,WAAW,IAAI,MAAM;CAOtB"}

package/dist/core/blob/blob_disk_driver.js

@@ -0,0 +1,179 @@
+import * as fs from "fs";
+import * as path from "path";
+export class BlobDiskDriver {
+    _directory;
+    encrypted;
+    constructor(directoryPath, encrypted) {
+        this._directory = directoryPath;
+        this.encrypted = encrypted;
+    }
+    async create() {
+        await fs.promises.mkdir(this._directory, { recursive: true });
+    }
+    createSync() {
+        fs.mkdirSync(this._directory, { recursive: true });
+    }
+    async destroy(force = false) {
+        if (!fs.existsSync(this._directory))
+            return;
+        const entities = fs.readdirSync(this._directory);
+        for (const name of entities) {
+            const entityPath = path.join(this._directory, name);
+            if (fs.lstatSync(entityPath).isDirectory() &&
+                path.basename(entityPath) === "_metadata")
+                continue;
+            await fs.promises.rm(entityPath, { recursive: force, force: true });
+        }
+    }
+    destroySync(force = false) {
+        if (!fs.existsSync(this._directory))
+            return;
+        const entities = fs.readdirSync(this._directory);
+        for (const name of entities) {
+            const entityPath = path.join(this._directory, name);
+            if (fs.lstatSync(entityPath).isDirectory() &&
+                path.basename(entityPath) === "_metadata")
+                continue;
+            fs.rmSync(entityPath, { recursive: force, force: true });
+        }
+    }
+    async add(bytes, fileId, chunkSize) {
+        const blobDirectory = path.join(this._directory, fileId);
+        await fs.promises.mkdir(blobDirectory, { recursive: true });
+        let chunkIndex = 0;
+        for (let i = 0; i < bytes.length; i += chunkSize, chunkIndex++) {
+            const end = i + chunkSize < bytes.length ? i + chunkSize : bytes.length;
+            const chunk = bytes.subarray(i, end);
+            const chunkFile = path.join(blobDirectory, `c_${chunkIndex}`);
+            await fs.promises.writeFile(chunkFile, chunk, { flag: "w" });
+        }
+        return bytes;
+    }
+    addSync(bytes, fileId, chunkSize) {
+        const blobDirectory = path.join(this._directory, fileId);
+        fs.mkdirSync(blobDirectory, { recursive: true });
+        let chunkIndex = 0;
+        for (let i = 0; i < bytes.length; i += chunkSize, chunkIndex++) {
+            const end = i + chunkSize < bytes.length ? i + chunkSize : bytes.length;
+            const chunk = bytes.subarray(i, end);
+            const chunkFile = path.join(blobDirectory, `c_${chunkIndex}`);
+            fs.writeFileSync(chunkFile, chunk, { flag: "w" });
+        }
+        return bytes;
+    }
+    async mergeChunks(fileId) {
+        const dir = path.join(this._directory, fileId);
+        if (!fs.existsSync(dir))
+            return null;
+        const files = fs
+            .readdirSync(dir)
+            .filter((f) => f.startsWith("c_"))
+            .sort((a, b) => this._chunkIndexFromPath(a) - this._chunkIndexFromPath(b));
+        const buffers = [];
+        for (const file of files) {
+            buffers.push(await fs.promises.readFile(path.join(dir, file)));
+        }
+        return Buffer.concat(buffers);
+    }
+    mergeChunksSync(fileId) {
+        const dir = path.join(this._directory, fileId);
+        if (!fs.existsSync(dir))
+            return null;
+        const files = fs
+            .readdirSync(dir)
+            .filter((f) => f.startsWith("c_"))
+            .sort((a, b) => this._chunkIndexFromPath(a) - this._chunkIndexFromPath(b));
+        const buffers = [];
+        for (const file of files) {
+            buffers.push(fs.readFileSync(path.join(dir, file)));
+        }
+        return Buffer.concat(buffers);
+    }
+    async *mergeChunksAsStream(fileId) {
+        const dir = path.join(this._directory, fileId);
+        if (!fs.existsSync(dir))
+            return;
+        const files = fs
+            .readdirSync(dir)
+            .filter((f) => f.startsWith("c_"))
+            .sort((a, b) => this._chunkIndexFromPath(a) - this._chunkIndexFromPath(b));
+        for (const file of files) {
+            yield await fs.promises.readFile(path.join(dir, file));
+        }
+        return;
+    }
+    _chunkIndexFromPath(filepath) {
+        const name = path.basename(filepath);
+        const idx = name.substring(2); // after 'c_'
+        return Number.parseInt(idx, 10) || 0;
+    }
+    getFileSize(fileId) {
+        const dir = path.join(this._directory, fileId);
+        if (!fs.existsSync(dir))
+            return 0;
+        return fs
+            .readdirSync(dir)
+            .filter((f) => f.startsWith("c_"))
+            .map((f) => fs.statSync(path.join(dir, f)).size)
+            .reduce((sum, curr) => sum + curr, 0);
+    }
+    async updateChunks(fileId, bytes, chunkSize) {
+        if (!(await this.exists(fileId)))
+            return null;
+        await this.deleteChunks(fileId);
+        return await this.add(bytes, fileId, chunkSize);
+    }
+    updateChunksSync(fileId, bytes, chunkSize) {
+        if (!this.existsSync(fileId))
+            return null;
+        this.deleteChunksSync(fileId);
+        return this.addSync(bytes, fileId, chunkSize);
+    }
+    async deleteChunks(fileId) {
+        if (await this.exists(fileId))
+            return;
+        const dir = path.join(this._directory, fileId);
+        await fs.promises.rm(dir, { recursive: true, force: true });
+    }
+    deleteChunksSync(fileId) {
+        if (this.existsSync(fileId))
+            return;
+        const dir = path.join(this._directory, fileId);
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    async exists(fileId) {
+        return await fs.promises.stat(path.join(this._directory, fileId)).then((stat) => stat.isDirectory(), () => false);
+    }
+    existsSync(fileId) {
+        try {
+            return fs.statSync(path.join(this._directory, fileId)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    async getCount() {
+        return (await fs.promises.readdir(this._directory)).length;
+    }
+    getCountSync() {
+        return fs.readdirSync(this._directory).length;
+    }
+    async getSize() {
+        let total = 0;
+        for await (const entry of await fs.promises.readdir(this._directory, {
+            withFileTypes: true,
+        })) {
+            if (entry.isFile()) {
+                total += (await fs.promises.stat(path.join(this._directory, entry.name))).size;
+            }
+        }
+        return total;
+    }
+    getSizeSync() {
+        return fs
+            .readdirSync(this._directory, { withFileTypes: true })
+            .filter((entry) => entry.isFile())
+            .map((entry) => fs.statSync(path.join(this._directory, entry.name)).size)
+            .reduce((sum, size) => sum + size, 0);
+    }
+}

package/dist/core/blob/blob_storage.d.ts

@@ -0,0 +1,90 @@
+import Collection from "../collection/collection";
+import { Buffer } from "buffer";
+import Blob from "./blob";
+import QueryBuilder from "../collection/query/query_builder";
+export default class BlobStorage {
+    private _name;
+    private _chunksSize;
+    private _collection;
+    private _blobDiskDriver;
+    constructor(opts: {
+        name: string;
+        path: string;
+        chunksSize: number;
+        encrypted: boolean;
+    });
+    add(bytes: Buffer, metadata?: {
+        [key: string]: any;
+    }): Promise<void>;
+    addSync(bytes: Buffer, metadata?: {
+        [key: string]: any;
+    }): void;
+    get(params?: {
+        query?: (collection: Collection) => QueryBuilder;
+        count?: number;
+    }): Promise<Blob[]>;
+    getSync(params?: {
+        query?: (collection: Collection) => QueryBuilder;
+        count?: number;
+    }): Blob[];
+    update(opts: {
+        query: (collection: Collection) => QueryBuilder;
+        metadata?: {
+            [key: string]: any;
+        };
+        bytes?: Buffer;
+    }): Promise<Blob[]>;
+    updateById(id: string, opts: {
+        metadata?: {
+            [key: string]: any;
+        };
+        bytes?: Buffer;
+    }): Promise<Blob | null>;
+    updateSync(opts: {
+        query: (collection: Collection) => QueryBuilder;
+        metadata?: {
+            [key: string]: any;
+        };
+        bytes?: Buffer;
+    }): Blob[];
+    updateSyncById(id: string, opts: {
+        metadata?: {
+            [key: string]: any;
+        };
+        bytes?: Buffer;
+    }): Blob | null;
+    delete(opts: {
+        query: (collection: Collection) => QueryBuilder;
+    }): Promise<void>;
+    deleteById(id: string): Promise<void>;
+    deleteSync(opts: {
+        query: (collection: Collection) => QueryBuilder;
+    }): void;
+    deleteSyncById(id: string): void;
+    clear(opts?: {
+        force?: boolean;
+    }): Promise<void>;
+    clearSync(opts?: {
+        force?: boolean;
+    }): void;
+    reset(opts?: {
+        force?: boolean;
+    }): Promise<void>;
+    resetSync(opts?: {
+        force?: boolean;
+    }): void;
+    isEmpty(): Promise<boolean>;
+    isEmptySync(): boolean;
+    size(): Promise<number>;
+    sizeSync(): number;
+    sizeAsHumanReadable(): Promise<string>;
+    sizeAsHumanReadableSync(): string;
+    count(): Promise<number>;
+    countSync(): number;
+    countAsHumanReadable(): Promise<string>;
+    countAsHumanReadableSync(): string;
+    private formatSize;
+    private formatNumber;
+    toString(): string;
+}
+//# sourceMappingURL=blob_storage.d.ts.map

package/dist/core/blob/blob_storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob_storage.d.ts","sourceRoot":"","sources":["../../../src/core/blob/blob_storage.ts"],"names":[],"mappings":"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"}

package/dist/core/blob/blob_storage.js

@@ -0,0 +1,248 @@
+import Collection from "../collection/collection";
+import { BlobDiskDriver } from "./blob_disk_driver";
+import { Buffer } from "buffer";
+import Blob from "./blob";
+import QueryBuilder from "../collection/query/query_builder";
+export default class BlobStorage {
+    _name;
+    _chunksSize;
+    _collection;
+    _blobDiskDriver;
+    constructor(opts) {
+        this._name = opts.name;
+        this._chunksSize = opts.chunksSize;
+        this._collection = new Collection({
+            name: opts.name,
+            path: `${opts.path}/_metadata`,
+            encrypted: false,
+        });
+        this._blobDiskDriver = new BlobDiskDriver(opts.path, opts.encrypted);
+        this._blobDiskDriver.createSync();
+    }
+    // ADD
+    async add(bytes, metadata) {
+        const document = await this._collection.add({
+            created_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+            ...(metadata || {}),
+        });
+        await this._blobDiskDriver.add(bytes, document.id, this._chunksSize);
+    }
+    addSync(bytes, metadata) {
+        const document = this._collection.addSync({
+            created_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+            ...(metadata || {}),
+        });
+        this._blobDiskDriver.addSync(bytes, document.id, this._chunksSize);
+    }
+    // GET
+    async get(params) {
+        let builder = params && params.query
+            ? params.query(this._collection)
+            : this._collection.builder;
+        if (params && params.count !== undefined)
+            builder = builder.limit(params.count);
+        const documents = await builder.get();
+        return documents.map((doc) => new Blob({
+            id: doc.id,
+            metadata: doc,
+            blobDiskDriver: this._blobDiskDriver,
+        }));
+    }
+    getSync(params) {
+        let builder = params && params.query
+            ? params.query(this._collection)
+            : this._collection.builder;
+        if (params && params.count !== undefined)
+            builder = builder.limit(params.count);
+        const rows = builder.getSync();
+        return rows.map((doc) => new Blob({
+            id: doc.id,
+            metadata: doc,
+            blobDiskDriver: this._blobDiskDriver,
+        }));
+    }
+    // UPDATE
+    async update(opts) {
+        const rows = await opts.query(this._collection).get();
+        const updatedRows = [];
+        for (const row of rows) {
+            let updatedRow;
+            if (opts.metadata && Object.keys(opts.metadata).length > 0) {
+                const data = { ...row.data, ...opts.metadata };
+                updatedRow = await this._collection.updateById(row.id, data);
+                if (updatedRow)
+                    updatedRows.push(updatedRow);
+            }
+            else {
+                updatedRow = row;
+            }
+            if (opts.bytes && opts.bytes.length > 0) {
+                await this._blobDiskDriver.updateChunks(row.id, opts.bytes, this._chunksSize);
+            }
+        }
+        return updatedRows.map((row) => new Blob({
+            id: row.id,
+            metadata: row,
+            blobDiskDriver: this._blobDiskDriver,
+        }));
+    }
+    async updateById(id, opts) {
+        const row = await this._collection.getById(id);
+        if (!row)
+            return null;
+        let updatedRow = row;
+        if (opts.metadata && Object.keys(opts.metadata).length > 0) {
+            const data = { ...row.data, ...opts.metadata };
+            const temp = await this._collection.updateById(row.id, data);
+            if (!temp)
+                return null;
+            updatedRow = temp;
+        }
+        if (opts.bytes && opts.bytes.length > 0) {
+            await this._blobDiskDriver.updateChunks(row.id, opts.bytes, this._chunksSize);
+        }
+        return new Blob({
+            id: updatedRow.id,
+            metadata: updatedRow,
+            blobDiskDriver: this._blobDiskDriver,
+        });
+    }
+    updateSync(opts) {
+        const rows = opts.query(this._collection).getSync();
+        const updatedBlobs = [];
+        for (const row of rows) {
+            let updatedRow = row;
+            if (opts.metadata && Object.keys(opts.metadata).length > 0) {
+                const data = { ...row.data, ...opts.metadata };
+                const temp = this._collection.updateByIdSync(row.id, data);
+                if (!temp)
+                    continue;
+                updatedRow = temp;
+            }
+            if (opts.bytes && opts.bytes.length > 0) {
+                this._blobDiskDriver.updateChunksSync(row.id, opts.bytes, this._chunksSize);
+            }
+            updatedBlobs.push(new Blob({
+                id: updatedRow.id,
+                metadata: updatedRow,
+                blobDiskDriver: this._blobDiskDriver,
+            }));
+        }
+        return updatedBlobs;
+    }
+    updateSyncById(id, opts) {
+        const row = this._collection.getByIdSync(id);
+        if (!row)
+            return null;
+        let updatedRow = row;
+        if (opts.metadata && Object.keys(opts.metadata).length > 0) {
+            const data = { ...row.data, ...opts.metadata };
+            const temp = this._collection.updateByIdSync(row.id, data);
+            if (!temp)
+                return null;
+            updatedRow = temp;
+        }
+        if (opts.bytes && opts.bytes.length > 0) {
+            this._blobDiskDriver.updateChunksSync(row.id, opts.bytes, this._chunksSize);
+        }
+        return new Blob({
+            id: updatedRow.id,
+            metadata: updatedRow,
+            blobDiskDriver: this._blobDiskDriver,
+        });
+    }
+    // DELETE
+    async delete(opts) {
+        const rows = await opts.query(this._collection).get();
+        for (const row of rows) {
+            await this._blobDiskDriver.deleteChunks(row.id);
+            await this._collection.deleteById(row.id);
+        }
+    }
+    async deleteById(id) {
+        await this._blobDiskDriver.deleteChunks(id);
+        await this._collection.deleteById(id);
+    }
+    deleteSync(opts) {
+        const rows = opts.query(this._collection).getSync();
+        for (const row of rows) {
+            this._blobDiskDriver.deleteChunksSync(row.id);
+            this._collection.deleteByIdSync(row.id);
+        }
+    }
+    deleteSyncById(id) {
+        this._blobDiskDriver.deleteChunksSync(id);
+        this._collection.deleteByIdSync(id);
+    }
+    // CLEAR
+    async clear(opts) {
+        await this._blobDiskDriver.destroy(opts?.force ?? false);
+        await this._collection.clear();
+    }
+    clearSync(opts) {
+        this._blobDiskDriver.destroySync(opts?.force ?? false);
+        this._collection.clearSync();
+    }
+    // RESET
+    async reset(opts) {
+        await this.clear(opts);
+    }
+    resetSync(opts) {
+        this.clearSync(opts);
+    }
+    // EMPTY
+    async isEmpty() {
+        return await this._collection.isEmpty();
+    }
+    isEmptySync() {
+        return this._collection.isEmptySync();
+    }
+    // Size
+    async size() {
+        return await this._blobDiskDriver.getSize();
+    }
+    sizeSync() {
+        return this._blobDiskDriver.getSizeSync();
+    }
+    async sizeAsHumanReadable() {
+        const size = await this.size();
+        return this.formatSize(size);
+    }
+    sizeAsHumanReadableSync() {
+        return this.formatSize(this.sizeSync());
+    }
+    // Count
+    async count() {
+        return await this._blobDiskDriver.getCount();
+    }
+    countSync() {
+        return this._blobDiskDriver.getCountSync();
+    }
+    async countAsHumanReadable() {
+        const count = await this.count();
+        return this.formatNumber(count);
+    }
+    countAsHumanReadableSync() {
+        return this.formatNumber(this.countSync());
+    }
+    formatSize(bytes) {
+        if (bytes < 1024)
+            return `${bytes} B`;
+        let kb = bytes / 1024;
+        if (kb < 1024)
+            return `${kb.toFixed(2)} KB`;
+        let mb = kb / 1024;
+        if (mb < 1024)
+            return `${mb.toFixed(2)} MB`;
+        let gb = mb / 1024;
+        return `${gb.toFixed(2)} GB`;
+    }
+    formatNumber(n) {
+        return n.toLocaleString("en-US");
+    }
+    toString() {
+        return `BlobStorage [ ${this._name} • ${this.sizeAsHumanReadableSync()} • ${this.countSync()} rows ]`;
+    }
+}