@wxn0brp/db-storage-bin 0.0.2

package/.github/workflows/build.yml

@@ -0,0 +1,24 @@
+name: Build
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - "*"
+
+  workflow_dispatch:
+
+concurrency:
+  group: build
+  cancel-in-progress: true
+
+jobs:
+  build:
+    uses: wxn0brP/workflow-dist/.github/workflows/build-ts.yml@main
+    with:
+      scriptsHandling: "remove-all"
+      publishToNpm: true
+
+    secrets:
+      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+### 0.0.2 (2025-08-24)
+
+
+### Features
+
+* check file integrality ([e2b1aac](https://github.com/wxn0brp/ValtheraDB-storage-bin/commit/e2b1aacddfd5d3cb8a21bb4400827608c361e9ed))
+* update ([cc2104c](https://github.com/wxn0brp/ValtheraDB-storage-bin/commit/cc2104c8dace53180efc76365930d63dd917d383))
+* update ([4e5a9a8](https://github.com/wxn0brp/ValtheraDB-storage-bin/commit/4e5a9a82ee01f96084d27b1cfd893e129d6675b7))
+* update ([fbec71a](https://github.com/wxn0brp/ValtheraDB-storage-bin/commit/fbec71a7cff65ed221ddbd7956bc252862e87760))
+* update ([e3b8edb](https://github.com/wxn0brp/ValtheraDB-storage-bin/commit/e3b8edb5c7f833ce0a948be878173e207946229b))
+* update ([65d73e4](https://github.com/wxn0brp/ValtheraDB-storage-bin/commit/65d73e4034944ecaa5963aa79d16a7fef795ce26))
+* update ([baebb1f](https://github.com/wxn0brp/ValtheraDB-storage-bin/commit/baebb1f4258303133ec315f72cffaefdbf252600))
+* update ([5f7c905](https://github.com/wxn0brp/ValtheraDB-storage-bin/commit/5f7c9053e97620cd2a5db4f9f703f5f8009f78ed))
+* update ([60d0347](https://github.com/wxn0brp/ValtheraDB-storage-bin/commit/60d0347b6f3ff562d851aee842c090d081ab0a8c))
+* update logs ([d79bd84](https://github.com/wxn0brp/ValtheraDB-storage-bin/commit/d79bd8439111f43ad4c99e44c860516695dc3123))
+
+
+### Bug Fixes
+
+* capacity ([05de295](https://github.com/wxn0brp/ValtheraDB-storage-bin/commit/05de2951c005f98697e067e3857a331777110110))
+* data len int32 to uint32 ([534a3b0](https://github.com/wxn0brp/ValtheraDB-storage-bin/commit/534a3b07d465320c0334a2fa557fb4bc070e7139))
+* optimize ([d704727](https://github.com/wxn0brp/ValtheraDB-storage-bin/commit/d7047276d31ccba5425de32fc28a8a65fcd5e02f))

package/LICENSE

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

package/README.md

@@ -0,0 +1,60 @@
+# ValtheraDB Bin Plugin
+
+This is a proof-of-concept for an addon/plugin for the `@wxn0brp/db` (ValtheraDB) library.
+
+The purpose of this experiment is to create a storage layer that allows ValtheraDB, which normally operates on a directory/file structure, to instead use a single binary file for data storage.
+
+## Installation
+
+```bash
+yarn add github:wxn0brP/ValtheraDB-storage-bin#dist
+```
+
+## Usage
+
+### Initialization
+
+To get started, create a new `BinValthera` instance:
+
+```typescript
+import { createBinValthera } from "@wxn0brp/db-storage-bin";
+
+const { db, actions, mgr } = await createBinValthera("test.val", { preferredSize: 4096 });
+```
+
+This will create a new binary file named `test.val` (if it doesn't exist) and initialize the database.
+
+### Basic
+
+The `db` object is an instance of `ValtheraClass` and supports the standard ValtheraDB methods.
+
+### Optimizing the Database
+
+This will reclaim unused space in the binary file.
+
+```typescript
+await mgr.optimize();
+```
+
+## API
+
+### `createBinValthera(path, opts, init)`
+
+-   `path`: The path to the binary file.
+-   `opts`: Options for the `BinManager`.
+-   `init`: Whether to initialize the database upon creation (default: `true`).
+
+Returns an object containing:
+-   `db`: An instance of `ValtheraClass`.
+-   `actions`: An instance of `BinFileAction`.
+-   `mgr`: An instance of `BinManager`.
+
+### `BinManager(path, options)`
+
+-   `path`: The path to the binary file.
+-   `options`:
+    -   `preferredSize`: The preferred block size for the database (default: `256`).
+
+## License
+
+This project is licensed under the MIT License.

package/dist/actions.d.ts

@@ -0,0 +1,64 @@
+import dbActionBase from "@wxn0brp/db-core/base/actions";
+import Data from "@wxn0brp/db-core/types/data";
+import FileCpu from "@wxn0brp/db-core/types/fileCpu";
+import { DbOpts } from "@wxn0brp/db-core/types/options";
+import { VQuery } from "@wxn0brp/db-core/types/query";
+import { BinManager } from "./bin/index.js";
+export declare class BinFileAction extends dbActionBase {
+    private mgr;
+    folder: string;
+    options: DbOpts;
+    fileCpu: FileCpu;
+    /**
+     * Creates a new instance of dbActionC.
+     * @constructor
+     * @param folder - The folder where database files are stored.
+     * @param options - The options object.
+     */
+    constructor(mgr: BinManager);
+    init(): Promise<void>;
+    /**
+     * Get a list of available databases in the specified folder.
+     */
+    getCollections(): Promise<string[]>;
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    ensureCollection({ collection }: VQuery): Promise<boolean>;
+    /**
+     * Check if a collection exists.
+     */
+    issetCollection({ collection }: VQuery): Promise<boolean>;
+    /**
+     * Add a new entry to the specified database.
+     */
+    add({ collection, data, id_gen }: VQuery): Promise<import("@wxn0brp/db-core/types/arg").Arg>;
+    /**
+     * Find entries in the specified database based on search criteria.
+     */
+    find(query: VQuery): Promise<Data[]>;
+    /**
+     * Find the first matching entry in the specified database based on search criteria.
+     */
+    findOne({ collection, search, context, findOpts }: VQuery): Promise<Data>;
+    /**
+     * Update entries in the specified database based on search criteria and an updater function or object.
+     */
+    update({ collection, search, updater, context }: VQuery): Promise<boolean>;
+    /**
+     * Update the first matching entry in the specified database based on search criteria and an updater function or object.
+     */
+    updateOne({ collection, search, updater, context }: VQuery): Promise<boolean>;
+    /**
+     * Remove entries from the specified database based on search criteria.
+     */
+    remove({ collection, search, context }: VQuery): Promise<boolean>;
+    /**
+     * Remove the first matching entry from the specified database based on search criteria.
+     */
+    removeOne({ collection, search, context }: VQuery): Promise<boolean>;
+    /**
+     * Removes a database collection from the file system.
+     */
+    removeCollection({ collection }: VQuery): Promise<boolean>;
+}

package/dist/actions.js

@@ -0,0 +1,106 @@
+import { CustomFileCpu, genId } from "@wxn0brp/db-core";
+import dbActionBase from "@wxn0brp/db-core/base/actions";
+import { findUtil } from "@wxn0brp/db-core/utils/action";
+export class BinFileAction extends dbActionBase {
+    mgr;
+    folder;
+    options;
+    fileCpu;
+    /**
+     * Creates a new instance of dbActionC.
+     * @constructor
+     * @param folder - The folder where database files are stored.
+     * @param options - The options object.
+     */
+    constructor(mgr) {
+        super();
+        this.mgr = mgr;
+        this.fileCpu = new CustomFileCpu(this.mgr.read.bind(this.mgr), this.mgr.write.bind(this.mgr));
+    }
+    async init() {
+        await this.mgr.open();
+    }
+    /**
+     * Get a list of available databases in the specified folder.
+     */
+    async getCollections() {
+        const collections = this.mgr.meta.collections.map(c => c.name);
+        return collections;
+    }
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    async ensureCollection({ collection }) {
+        if (await this.issetCollection(arguments[0]))
+            return;
+        await this.mgr.write(collection, []);
+        return true;
+    }
+    /**
+     * Check if a collection exists.
+     */
+    async issetCollection({ collection }) {
+        const collections = await this.getCollections();
+        return collections.includes(collection);
+    }
+    /**
+     * Add a new entry to the specified database.
+     */
+    async add({ collection, data, id_gen = true }) {
+        await this.ensureCollection(arguments[0]);
+        if (id_gen)
+            data._id = data._id || genId();
+        await this.fileCpu.add(collection, data);
+        return data;
+    }
+    /**
+     * Find entries in the specified database based on search criteria.
+     */
+    async find(query) {
+        await this.ensureCollection(query);
+        return await findUtil(query, this.fileCpu, [query.collection]);
+    }
+    /**
+     * Find the first matching entry in the specified database based on search criteria.
+     */
+    async findOne({ collection, search, context = {}, findOpts = {} }) {
+        await this.ensureCollection(arguments[0]);
+        let data = await this.fileCpu.findOne(collection, search, context, findOpts);
+        return data || null;
+    }
+    /**
+     * Update entries in the specified database based on search criteria and an updater function or object.
+     */
+    async update({ collection, search, updater, context = {} }) {
+        await this.ensureCollection(arguments[0]);
+        return await this.fileCpu.update(collection, false, search, updater, context);
+    }
+    /**
+     * Update the first matching entry in the specified database based on search criteria and an updater function or object.
+     */
+    async updateOne({ collection, search, updater, context = {} }) {
+        await this.ensureCollection(arguments[0]);
+        return await this.fileCpu.update(collection, true, search, updater, context);
+    }
+    /**
+     * Remove entries from the specified database based on search criteria.
+     */
+    async remove({ collection, search, context = {} }) {
+        await this.ensureCollection(arguments[0]);
+        return await this.fileCpu.remove(collection, false, search, context);
+    }
+    /**
+     * Remove the first matching entry from the specified database based on search criteria.
+     */
+    async removeOne({ collection, search, context = {} }) {
+        await this.ensureCollection(arguments[0]);
+        return await this.fileCpu.remove(collection, true, search, context);
+    }
+    /**
+     * Removes a database collection from the file system.
+     */
+    async removeCollection({ collection }) {
+        await this.mgr.removeCollection(collection);
+        return true;
+    }
+}

package/dist/bin/data.d.ts

@@ -0,0 +1,6 @@
+import { BinManager, CollectionMeta } from "./index.js";
+import { FileMeta } from "./head.js";
+export declare function findCollection(cmp: BinManager, name: string): CollectionMeta | undefined;
+export declare function findFreeSlot(cmp: BinManager, size: number): Promise<FileMeta["freeList"][number] | undefined>;
+export declare function writeLogic(cmp: BinManager, collection: string, data: object[]): Promise<void>;
+export declare function readLogic(cmp: BinManager, collection: string): Promise<any>;

package/dist/bin/data.js

@@ -0,0 +1,80 @@
+import { _log } from "../log.js";
+import { saveHeaderAndPayload } from "./head.js";
+import { detectCollisions, pushToFreeList, readData, roundUpCapacity, writeData } from "./utils.js";
+export function findCollection(cmp, name) {
+    return cmp.meta.collections.find(c => c.name === name);
+}
+export async function findFreeSlot(cmp, size) {
+    const { meta } = cmp;
+    await _log(6, "Finding free slot for size:", size);
+    const idx = meta.freeList.findIndex(f => f.capacity >= size);
+    if (idx === -1) {
+        await _log(6, "No suitable free slot found.");
+        return undefined;
+    }
+    const slot = meta.freeList[idx];
+    await _log(6, "Free slot found at index:", idx, "with capacity:", slot.capacity);
+    meta.freeList.splice(idx, 1);
+    await _log(6, "Slot removed from freeList:", slot);
+    return slot;
+}
+export async function writeLogic(cmp, collection, data) {
+    const { fd, meta } = cmp;
+    await _log(3, "Writing data to collection:", collection);
+    const existingCollection = findCollection(cmp, collection);
+    const encoded = Buffer.from(await cmp.options.format.encode(data));
+    const length = encoded.length;
+    const capacity = roundUpCapacity(meta, length + 4);
+    let offset = existingCollection?.offset;
+    let existingOffset = existingCollection?.offset;
+    let existingCapacity = existingCollection?.capacity;
+    const collision = detectCollisions(meta, offset, capacity, [collection]);
+    if (collision || !existingCollection) {
+        if (collision)
+            await _log(2, "Collision detected");
+        const slot = await findFreeSlot(cmp, capacity);
+        if (slot) {
+            offset = slot.offset;
+            await _log(4, "Found free slot at offset:", offset);
+        }
+        else {
+            offset = meta.fileSize;
+            meta.fileSize += capacity;
+            await _log(4, "No free slot found, appending at offset:", offset);
+        }
+        if (!existingCollection) {
+            meta.collections.push({ name: collection, offset, capacity });
+        }
+        else if (collision) {
+            pushToFreeList(meta, existingOffset, existingCapacity);
+            meta.collections = meta.collections.map(c => {
+                if (c.offset === existingOffset)
+                    return { name: c.name, offset, capacity };
+                return c;
+            });
+        }
+        await _log(3, "Collection written");
+        await saveHeaderAndPayload(cmp);
+    }
+    const buf = Buffer.alloc(4);
+    buf.writeUInt32LE(length, 0);
+    await writeData(fd, offset, buf, 4);
+    await writeData(fd, offset + 4, encoded, capacity);
+    if (existingCollection && length >= existingCollection.capacity) {
+        meta.collections = meta.collections.map(c => {
+            if (c.offset === offset)
+                return { name: c.name, offset, capacity };
+            return c;
+        });
+        await saveHeaderAndPayload(cmp);
+        await _log(2, "Capacity exceeded");
+    }
+}
+export async function readLogic(cmp, collection) {
+    const collectionMeta = findCollection(cmp, collection);
+    if (!collectionMeta)
+        throw new Error("Collection not found");
+    const len = await readData(cmp.fd, collectionMeta.offset, 4);
+    const data = await readData(cmp.fd, collectionMeta.offset + 4, len.readUInt32LE(0));
+    return await cmp.options.format.decode(data);
+}

package/dist/bin/head.d.ts

@@ -0,0 +1,20 @@
+import { BinManager, CollectionMeta } from "./index.js";
+export interface Block {
+    offset: number;
+    capacity: number;
+}
+export interface FileMeta {
+    collections: CollectionMeta[];
+    freeList: Block[];
+    fileSize: number;
+    payloadLength: number;
+    payloadOffset: number;
+    blockSize: number;
+}
+export declare function openFile(cmp: BinManager): Promise<FileMeta>;
+export declare function readHeaderPayload(cmp: BinManager): Promise<void>;
+export declare function getHeaderPayload(meta: FileMeta): {
+    c: (string | number)[][];
+    f: number[][];
+};
+export declare function saveHeaderAndPayload(cmp: BinManager, recursion?: boolean): Promise<void>;

package/dist/bin/head.js

@@ -0,0 +1,135 @@
+import { getFileCrc } from "../crc32.js";
+import { _log } from "../log.js";
+import { findFreeSlot } from "./data.js";
+import { HEADER_SIZE, VERSION } from "./static.js";
+import { detectCollisions, pushToFreeList, roundUpCapacity, writeData } from "./utils.js";
+;
+export async function openFile(cmp) {
+    const { fd, options } = cmp;
+    const stats = await fd.stat();
+    const fileSize = stats.size;
+    await _log(2, "File size:", fileSize);
+    const meta = {
+        collections: [],
+        freeList: [],
+        fileSize,
+        payloadLength: 0,
+        payloadOffset: 0,
+        blockSize: options.preferredSize ?? 256,
+    };
+    cmp.meta = meta;
+    if (fileSize < HEADER_SIZE) {
+        await _log(2, "Initializing new file header");
+        await saveHeaderAndPayload(cmp);
+        await _log(6, "Header initialized with size:", HEADER_SIZE);
+        return meta;
+    }
+    const headerBuf = Buffer.alloc(HEADER_SIZE);
+    await fd.read(headerBuf, 0, HEADER_SIZE, 0);
+    await _log(6, "Header read from file");
+    const version = headerBuf.readUInt32LE(0);
+    if (version !== VERSION) {
+        await _log(6, "err", `Unsupported file version: ${version}`);
+        throw new Error(`Unsupported file version ${version}`);
+    }
+    await _log(2, "File version:", version);
+    const payloadLength = headerBuf.readUInt32LE(4);
+    meta.payloadLength = payloadLength;
+    await _log(6, "Payload length:", payloadLength);
+    const payloadOffset = headerBuf.readUInt32LE(8);
+    meta.payloadOffset = payloadOffset;
+    await _log(6, "Payload offset:", payloadOffset);
+    const blockSize = headerBuf.readUInt32LE(12);
+    meta.blockSize = blockSize;
+    await _log(2, "Block size:", blockSize);
+    if (options.crc) {
+        const { computedCrc, storedCrc } = await getFileCrc(fd);
+        const validCrc = computedCrc === storedCrc || storedCrc === 0;
+        await _log(2, "CRC:", computedCrc, "Needed CRC:", storedCrc, "Valid:", validCrc);
+        if (storedCrc === 0) {
+            await _log(1, "Warning: CRC is zero, CRC will not be checked");
+        }
+        if (!validCrc) {
+            await _log(0, "err", "Invalid CRC");
+            if (options.crc === 2)
+                throw new Error("Invalid CRC");
+        }
+    }
+    if (payloadOffset + payloadLength > fileSize - HEADER_SIZE) {
+        await _log(6, "err", "Invalid payload length");
+        throw new Error("Invalid payload length");
+    }
+    if (payloadLength === 0) {
+        await _log(6, "Empty payload, initializing collections and freeList");
+        return meta;
+    }
+    await readHeaderPayload(cmp);
+    return meta;
+}
+export async function readHeaderPayload(cmp) {
+    const { fd, meta } = cmp;
+    const { payloadLength, payloadOffset } = meta;
+    const payloadBuf = Buffer.alloc(payloadLength);
+    const { bytesRead } = await fd.read(payloadBuf, 0, payloadLength, HEADER_SIZE + payloadOffset);
+    await _log(6, `Payload header read, bytesRead: ${bytesRead}`);
+    if (bytesRead < payloadLength) {
+        await _log(6, "err", `Incomplete payload header read: expected ${payloadLength} bytes, got ${bytesRead}`);
+        throw new Error(`Incomplete payload header read: expected ${payloadLength} bytes, got ${bytesRead}`);
+    }
+    const obj = await cmp.options.format.decode(payloadBuf);
+    meta.collections = (obj.c || []).map(([name, offset, capacity]) => ({ name, offset, capacity }));
+    meta.freeList = (obj.f || []).map(([offset, capacity]) => ({ offset, capacity }));
+    await _log(6, "Collections and freeList loaded", meta);
+}
+export function getHeaderPayload(meta) {
+    return {
+        c: meta.collections.map(({ name, offset, capacity }) => ([name, offset, capacity])),
+        f: meta.freeList.map(({ offset, capacity }) => [offset, capacity]),
+    };
+}
+export async function saveHeaderAndPayload(cmp, recursion = false) {
+    const { fd, meta, options } = cmp;
+    if (!fd)
+        throw new Error("File not open");
+    const { collections, freeList, fileSize } = meta;
+    await _log(6, "Saving header payload:", collections, freeList);
+    const payloadObj = getHeaderPayload(meta);
+    const payloadBuf = Buffer.from(await cmp.options.format.encode(payloadObj));
+    if (payloadBuf.length > 64 * 1024) {
+        console.error("Header payload too large");
+        throw new Error("Header payload too large");
+    }
+    await _log(6, "Header payload length:", payloadBuf.length);
+    const headerBuf = Buffer.alloc(HEADER_SIZE);
+    headerBuf.writeUInt32LE(VERSION, 0);
+    headerBuf.writeUInt32LE(payloadBuf.length, 4);
+    headerBuf.writeUInt32LE(meta.payloadOffset, 8);
+    headerBuf.writeUInt32LE(meta.blockSize, 12);
+    meta.payloadLength = payloadBuf.length;
+    if (options.crc) {
+        const { computedCrc: crc } = await getFileCrc(fd);
+        headerBuf.writeUInt32LE(crc, 16);
+    }
+    await _log(6, "Writing header:", headerBuf.toString("hex"));
+    // Write header
+    await fd.write(headerBuf, 0, HEADER_SIZE, 0);
+    // Write payload
+    const roundPayload = roundUpCapacity(meta, payloadBuf.length);
+    if (detectCollisions(meta, HEADER_SIZE + meta.payloadOffset, roundPayload)) {
+        await _log(2, "Collision detected");
+        const slot = !recursion && await findFreeSlot(cmp, roundPayload);
+        if (slot) {
+            meta.payloadOffset = slot.offset - HEADER_SIZE;
+        }
+        else {
+            meta.payloadOffset = meta.fileSize - HEADER_SIZE;
+            meta.fileSize += roundPayload;
+        }
+        pushToFreeList(meta, meta.payloadOffset, roundPayload);
+        return await saveHeaderAndPayload(cmp, true);
+    }
+    await writeData(fd, HEADER_SIZE + meta.payloadOffset, payloadBuf, roundPayload);
+    await _log(6, "Payload written");
+    // Update file size if header + payload bigger
+    meta.fileSize = Math.max(fileSize, HEADER_SIZE + roundPayload);
+}

package/dist/bin/index.d.ts

@@ -0,0 +1,41 @@
+import { FileHandle } from "fs/promises";
+import { FileMeta } from "./head.js";
+export interface CollectionMeta {
+    name: string;
+    offset: number;
+    capacity: number;
+}
+export interface Options {
+    preferredSize: number;
+    /**
+     * 0 - crc off
+     * 1 - warn if error
+     * 2 - throw if error
+     */
+    crc: number;
+    overwriteRemovedCollection: boolean;
+    format: {
+        encode(data: any): Promise<Parameters<typeof Buffer.from>[0]>;
+        decode(data: Buffer): Promise<any>;
+    };
+}
+export declare class BinManager {
+    path: string;
+    fd: null | FileHandle;
+    meta: FileMeta;
+    options: Options;
+    /**
+     * Constructs a new BinManager instance.
+     * @param path - File path.
+     * @param [preferredSize=512] - The preferred block size for the database. Must be a positive number (preferredSize > 0)
+     * @throws If the path is not provided, or the preferred size is
+     * not a positive number.
+     */
+    constructor(path: string, options?: Partial<Options>);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    write(collection: string, data: object[]): Promise<void>;
+    read(collection: string): Promise<any>;
+    optimize(): Promise<void>;
+    removeCollection(collection: string): Promise<void>;
+}

package/dist/bin/index.js

@@ -0,0 +1,87 @@
+import * as msgpack from "@msgpack/msgpack";
+import { access, constants, open } from "fs/promises";
+import { getFileCrc } from "../crc32.js";
+import { _log } from "../log.js";
+import { readLogic, writeLogic } from "./data.js";
+import { openFile } from "./head.js";
+import { optimize } from "./optimize.js";
+import { removeCollection } from "./rm.js";
+async function safeOpen(path) {
+    try {
+        await access(path, constants.F_OK);
+        return await open(path, "r+");
+    }
+    catch {
+        _log(1, "Creating new file");
+        return await open(path, "w+");
+    }
+}
+export class BinManager {
+    path;
+    fd = null;
+    meta;
+    options;
+    /**
+     * Constructs a new BinManager instance.
+     * @param path - File path.
+     * @param [preferredSize=512] - The preferred block size for the database. Must be a positive number (preferredSize > 0)
+     * @throws If the path is not provided, or the preferred size is
+     * not a positive number.
+     */
+    constructor(path, options) {
+        this.path = path;
+        if (!path)
+            throw new Error("Path not provided");
+        this.options = {
+            preferredSize: 512,
+            crc: 2,
+            overwriteRemovedCollection: false,
+            format: {
+                encode: async (data) => msgpack.encode(data),
+                decode: async (data) => msgpack.decode(data)
+            },
+            ...options
+        };
+        if (!this.options.preferredSize || this.options.preferredSize <= 0)
+            throw new Error("Preferred size not provided");
+    }
+    async open() {
+        this.fd = await safeOpen(this.path);
+        await openFile(this);
+    }
+    async close() {
+        if (this.fd) {
+            const buff = Buffer.alloc(8);
+            if (this.options.crc) {
+                const { computedCrc: crc } = await getFileCrc(this.fd);
+                buff.writeUInt32LE(crc, 0);
+            }
+            else {
+                buff.fill(0, 0, 8);
+            }
+            await this.fd.write(buff, 0, 8, 16);
+            await this.fd.close();
+            this.fd = null;
+        }
+    }
+    async write(collection, data) {
+        if (!this.fd)
+            throw new Error("File not open");
+        await writeLogic(this, collection, data);
+    }
+    async read(collection) {
+        if (!this.fd)
+            throw new Error("File not open");
+        return await readLogic(this, collection);
+    }
+    async optimize() {
+        if (!this.fd)
+            throw new Error("File not open");
+        await optimize(this);
+    }
+    async removeCollection(collection) {
+        if (!this.fd)
+            throw new Error("File not open");
+        await removeCollection(this, collection);
+    }
+}

package/dist/bin/optimize.d.ts

@@ -0,0 +1,2 @@
+import { BinManager } from "./index.js";
+export declare function optimize(cmp: BinManager): Promise<void>;