@wxn0brp/db-storage-bin 0.100.2 → 0.110.0-alpha.0

package/dist/bin/add.d.ts

@@ -0,0 +1,3 @@
+import { VQueryT } from "@wxn0brp/db-core/types/query";
+import { BinManager } from "./index.js";
+export declare function add(cmp: BinManager, config: VQueryT.Add): Promise<void>;

package/dist/bin/add.js

@@ -0,0 +1,27 @@
+import { _log } from "../log.js";
+import { ensureCollection } from "./collection.js";
+import { INT_SIZE } from "./static.js";
+import { readCollectionEof, writeData } from "./utils.js";
+export async function add(cmp, config) {
+    const { data } = config;
+    const { fd } = cmp;
+    await _log(3, "Writing data to collection:", config.collection);
+    const encoded = Buffer.from(await cmp.options.format.encode(data, config.collection));
+    const length = encoded.length;
+    await _log(5, "Encoded data length:", length);
+    const collection = await ensureCollection(cmp, config.collection, length, true);
+    const collectionEOF = await readCollectionEof(fd, collection.offset);
+    await _log(5, "Read collection EOF:", collectionEOF);
+    // skip: collection length metadata + collection length
+    const offset = collection.offset + collectionEOF + INT_SIZE;
+    await _log(5, "Calculated offset:", offset);
+    const dataLengthBuffer = Buffer.alloc(INT_SIZE);
+    dataLengthBuffer.writeUInt32LE(length, 0);
+    await writeData(fd, offset, dataLengthBuffer, INT_SIZE);
+    await writeData(fd, offset + INT_SIZE, encoded, length);
+    const newEOF = collectionEOF + INT_SIZE + length;
+    await _log(5, "New collection EOF:", newEOF);
+    const collectionLengthBuffer = Buffer.alloc(INT_SIZE);
+    collectionLengthBuffer.writeUInt32LE(newEOF, 0);
+    await writeData(fd, collection.offset, collectionLengthBuffer, INT_SIZE);
+}

package/dist/bin/collection.d.ts

@@ -0,0 +1,2 @@
+import { BinManager, CollectionMeta } from "./index.js";
+export declare function ensureCollection(cmp: BinManager, name: string, length: number, append: boolean): Promise<CollectionMeta>;

package/dist/bin/collection.js

@@ -0,0 +1,82 @@
+import { _log } from "../log.js";
+import { findCollection, getFreeSlot } from "./data.js";
+import { saveHeaderAndPayload } from "./head.js";
+import { INT_SIZE } from "./static.js";
+import { readCollectionEof, readData, roundUpCapacity, writeData } from "./utils.js";
+export async function ensureCollection(cmp, name, length, append) {
+    let lengthToStore;
+    const existingCollection = findCollection(cmp, name);
+    const isLastCollection = existingCollection && cmp.meta.collections[cmp.meta.collections.length - 1].offset === existingCollection.offset;
+    if (existingCollection) {
+        if (append) {
+            const collectionEOF = await readCollectionEof(cmp.fd, existingCollection.offset);
+            lengthToStore = roundUpCapacity(cmp.meta, INT_SIZE + collectionEOF + INT_SIZE + length);
+            await _log(6, "Append mode, calculated lengthToStore:", lengthToStore);
+        }
+        else {
+            lengthToStore = roundUpCapacity(cmp.meta, length + INT_SIZE);
+        }
+        await _log(6, "Existing collection found:", existingCollection.name, "capacity:", existingCollection.capacity, "needed:", lengthToStore);
+        if (existingCollection.capacity >= lengthToStore) {
+            await _log(5, "Existing collection has enough capacity, reusing");
+            return existingCollection;
+        }
+        await _log(5, "Existing collection too small, moving to free list and creating new");
+        cmp.meta.collections = cmp.meta.collections.filter(c => c.name !== name);
+    }
+    else {
+        lengthToStore = roundUpCapacity(cmp.meta, length + INT_SIZE);
+        await _log(6, "No existing collection found, calculated lengthToStore:", lengthToStore);
+    }
+    let newCollection;
+    // if exists and is last collection -> reuse offset
+    if (existingCollection && isLastCollection) {
+        newCollection = { name, offset: existingCollection.offset, capacity: lengthToStore };
+        cmp.meta.fileSize += lengthToStore - existingCollection.capacity;
+    }
+    else {
+        const slot = await getFreeSlot(cmp, lengthToStore);
+        if (slot) {
+            await _log(6, "Using free slot at offset:", slot.offset, "capacity:", slot.capacity);
+            newCollection = { name, offset: slot.offset, capacity: slot.capacity };
+        }
+        else {
+            await _log(6, "No free slot, appending at offset:", cmp.meta.fileSize);
+            newCollection = { name, offset: cmp.meta.fileSize, capacity: lengthToStore };
+            cmp.meta.fileSize += lengthToStore;
+        }
+    }
+    cmp.meta.collections.push(newCollection);
+    if (existingCollection) {
+        if (!isLastCollection) {
+            const chunkSize = 2048;
+            const tmpBuffer = Buffer.alloc(chunkSize);
+            const collectionLength = (await readData(cmp.fd, existingCollection.offset, INT_SIZE)).readUInt32LE(0);
+            const loopCount = Math.floor((collectionLength + INT_SIZE) / chunkSize);
+            await _log(3, "Copying", collectionLength, "bytes from old offset", existingCollection.offset, "to new offset", newCollection.offset);
+            for (let i = 0; i < loopCount; i++) {
+                const readDataOffset = existingCollection.offset + i * chunkSize;
+                const writeDataOffset = newCollection.offset + i * chunkSize;
+                await cmp.fd.read(tmpBuffer, 0, chunkSize, readDataOffset);
+                await cmp.fd.write(tmpBuffer, 0, chunkSize, writeDataOffset);
+            }
+            const lastChunkSize = (collectionLength + INT_SIZE) % chunkSize;
+            if (lastChunkSize) {
+                const readDataOffset = existingCollection.offset + loopCount * chunkSize;
+                const writeDataOffset = newCollection.offset + loopCount * chunkSize;
+                await cmp.fd.read(tmpBuffer, 0, lastChunkSize, readDataOffset);
+                await cmp.fd.write(tmpBuffer, 0, lastChunkSize, writeDataOffset);
+            }
+            cmp.meta.freeList.push(existingCollection);
+        }
+    }
+    else {
+        // Write 0 length for new collection
+        const collectionLengthBuffer = Buffer.alloc(INT_SIZE);
+        collectionLengthBuffer.writeUInt32LE(0, 0);
+        await writeData(cmp.fd, newCollection.offset, collectionLengthBuffer, INT_SIZE);
+    }
+    await saveHeaderAndPayload(cmp);
+    await _log(5, "Collection ensured:", newCollection);
+    return newCollection;
+}

package/dist/bin/data.d.ts

@@ -1,6 +1,4 @@
 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: any): Promise<void>;
-export declare function readLogic(cmp: BinManager, collection: string): Promise<any>;
+export declare function getFreeSlot(cmp: BinManager, size: number): Promise<FileMeta["freeList"][number] | undefined>;

package/dist/bin/data.js

@@ -1,11 +1,8 @@
-import { getFileCrc } from "../crc32.js";
 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) {
+export async function getFreeSlot(cmp, size) {
     const { meta } = cmp;
     await _log(6, "Finding free slot for size:", size);
     const idx = meta.freeList.findIndex(f => f.capacity >= size);
@@ -19,72 +16,3 @@ export async function findFreeSlot(cmp, size) {
     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, collection));
-    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 - 4);
-    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");
-    }
-    else {
-        const crc = cmp.options.crc;
-        if (crc === 3 || crc === 4) {
-            const { computedCrc } = await getFileCrc(fd);
-            const crcBuf = Buffer.alloc(16);
-            crcBuf.writeUInt32LE(computedCrc);
-            await writeData(fd, 16, crcBuf, 16);
-        }
-    }
-}
-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, collection);
-}

package/dist/bin/find.d.ts

@@ -0,0 +1,5 @@
+import { DataInternal } from "@wxn0brp/db-core/types/data";
+import { BinManager } from "./index.js";
+import { VQueryT } from "@wxn0brp/db-core/types/query";
+export declare function findOne(cmp: BinManager, config: VQueryT.FindOne): Promise<DataInternal | null>;
+export declare function find(cmp: BinManager, config: VQueryT.Find): Promise<DataInternal[]>;

package/dist/bin/find.js

@@ -0,0 +1,52 @@
+import { _log } from "../log.js";
+import { findCollection } from "./data.js";
+import { INT_SIZE } from "./static.js";
+import { readCollectionEof, readData } from "./utils.js";
+import { findObj } from "@wxn0brp/db-core/utils/process";
+export async function findOne(cmp, config) {
+    await _log(2, "Find one in collection:", config.collection);
+    const collection = findCollection(cmp, config.collection);
+    let cursor = collection.offset + INT_SIZE;
+    const collectionEOF = (await readData(cmp.fd, collection.offset, INT_SIZE)).readUInt32LE(0);
+    if (collectionEOF === 0)
+        return null;
+    const endOffset = collection.offset + INT_SIZE + collectionEOF;
+    while (cursor < endOffset) {
+        const dataLength = (await readData(cmp.fd, cursor, INT_SIZE)).readUInt32LE(0);
+        cursor += INT_SIZE;
+        const data = await readData(cmp.fd, cursor, dataLength);
+        cursor += dataLength;
+        // if removed
+        if (new Uint8Array(data).every(byte => byte === 0))
+            continue;
+        const obj = await cmp.options.format.decode(data, config.collection);
+        const res = findObj(config, obj);
+        if (res)
+            return res;
+    }
+    return null;
+}
+export async function find(cmp, config) {
+    await _log(2, "Find in collection:", config.collection);
+    const collection = findCollection(cmp, config.collection);
+    let cursor = collection.offset + INT_SIZE;
+    const collectionEOF = await readCollectionEof(cmp.fd, collection.offset);
+    if (collectionEOF === 0)
+        return [];
+    const res = [];
+    const endOffset = collection.offset + INT_SIZE + collectionEOF;
+    while (cursor < endOffset) {
+        const dataLength = (await readData(cmp.fd, cursor, INT_SIZE)).readUInt32LE(0);
+        cursor += INT_SIZE;
+        const data = await readData(cmp.fd, cursor, dataLength);
+        cursor += dataLength;
+        // if removed
+        if (new Uint8Array(data).every(byte => byte === 0))
+            continue;
+        const obj = await cmp.options.format.decode(data, config.collection);
+        const match = findObj(config, obj);
+        if (match)
+            res.push(match);
+    }
+    return res;
+}

package/dist/bin/head.d.ts

@@ -13,8 +13,5 @@ export interface FileMeta {
 }
 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 getHeaderPayload(meta: FileMeta): (string | number)[][][];
 export declare function saveHeaderAndPayload(cmp: BinManager, recursion?: boolean): Promise<void>;

package/dist/bin/head.js

@@ -1,6 +1,5 @@
-import { getFileCrc } from "../crc32.js";
 import { _log } from "../log.js";
-import { findFreeSlot } from "./data.js";
+import { getFreeSlot } from "./data.js";
 import { HEADER_SIZE, VERSION } from "./static.js";
 import { detectCollisions, pushToFreeList, roundUpCapacity, writeData } from "./utils.js";
 ;
@@ -42,19 +41,6 @@ export async function openFile(cmp) {
     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 || options.crc === 4)
-                throw new Error("Invalid CRC");
-        }
-    }
     if (payloadOffset + payloadLength > fileSize - HEADER_SIZE) {
         await _log(6, "err", "Invalid payload length");
         throw new Error("Invalid payload length");
@@ -77,15 +63,15 @@ export async function readHeaderPayload(cmp) {
         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 }));
+    meta.collections = obj[0].map(([name, offset, capacity]) => ({ name, offset, capacity }));
+    meta.freeList = obj[1].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]),
-    };
+    return [
+        meta.collections.map(({ name, offset, capacity }) => ([name, offset, capacity])),
+        meta.freeList.map(({ offset, capacity }) => [offset, capacity]),
+    ];
 }
 export async function saveHeaderAndPayload(cmp, recursion = false) {
     const { fd, meta, options } = cmp;
@@ -94,7 +80,7 @@ export async function saveHeaderAndPayload(cmp, recursion = false) {
     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, ""));
+    const payloadBuf = Buffer.from(await options.format.encode(payloadObj, ""));
     if (payloadBuf.length > 64 * 1024) {
         console.error("Header payload too large");
         throw new Error("Header payload too large");
@@ -106,10 +92,6 @@ export async function saveHeaderAndPayload(cmp, recursion = false) {
     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);
@@ -117,7 +99,7 @@ export async function saveHeaderAndPayload(cmp, recursion = false) {
     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);
+        const slot = !recursion && await getFreeSlot(cmp, roundPayload);
         if (slot) {
             meta.payloadOffset = slot.offset - HEADER_SIZE;
         }

package/dist/bin/index.d.ts

@@ -1,3 +1,6 @@
+import { ActionsBase } from "@wxn0brp/db-core/base/actions";
+import { DataInternal } from "@wxn0brp/db-core/types/data";
+import { VQueryT } from "@wxn0brp/db-core/types/query";
 import { FileHandle } from "fs/promises";
 import { FileMeta } from "./head.js";
 export interface CollectionMeta {
@@ -7,25 +10,18 @@ export interface CollectionMeta {
 }
 export interface Options {
     preferredSize: number;
-    /**
-     * 0 - crc off
-     * 1 - warn if error
-     * 2 - throw if error
-     * 3 - 1 & save always on edit
-     * 4 - 2 & save always on edit
-     */
-    crc: number;
     overwriteRemovedCollection: boolean;
     format: {
         encode(data: any, collection: string): Promise<Parameters<typeof Buffer.from>[0]>;
         decode(data: Buffer, collection: string): Promise<any>;
     };
 }
-export declare class BinManager {
+export declare class BinManager extends ActionsBase {
     path: string;
     fd: null | FileHandle;
     meta: FileMeta;
     options: Options;
+    _inited: boolean;
     /**
      * Constructs a new BinManager instance.
      * @param path - File path.
@@ -34,11 +30,19 @@ export declare class BinManager {
      * not a positive number.
      */
     constructor(path: string, options?: Partial<Options>);
-    open(): Promise<void>;
+    init(): Promise<void>;
     close(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
-    write<T = object[]>(collection: string, data: T): Promise<void>;
-    read(collection: string): Promise<any>;
+    getCollections(): Promise<string[]>;
+    issetCollection(collection: string): Promise<boolean>;
+    ensureCollection(collection: string): Promise<boolean>;
     optimize(): Promise<void>;
-    removeCollection(collection: string): Promise<void>;
+    removeCollection(collection: string): Promise<boolean>;
+    add(config: VQueryT.Add): Promise<DataInternal>;
+    find(config: VQueryT.Find): Promise<DataInternal[]>;
+    findOne(config: VQueryT.FindOne): Promise<DataInternal | null>;
+    update(config: VQueryT.Update): Promise<DataInternal[]>;
+    updateOne(config: VQueryT.Update): Promise<DataInternal | null>;
+    remove(config: VQueryT.Remove): Promise<DataInternal[]>;
+    removeOne(config: VQueryT.Remove): Promise<DataInternal | null>;
 }

package/dist/bin/index.js

@@ -1,11 +1,17 @@
 import * as msgpack from "@msgpack/msgpack";
+import { ActionsBase } from "@wxn0brp/db-core/base/actions";
+import { addId } from "@wxn0brp/db-core/helpers/addId";
+import { findUtil } from "@wxn0brp/db-core/utils/action";
 import { access, constants, open } from "fs/promises";
-import { getFileCrc } from "../crc32.js";
 import { _log } from "../log.js";
-import { readLogic, writeLogic } from "./data.js";
+import { add } from "./add.js";
+import { ensureCollection } from "./collection.js";
+import { find, findOne } from "./find.js";
 import { openFile } from "./head.js";
 import { optimize } from "./optimize.js";
-import { removeCollection } from "./rm.js";
+import { removeCollection } from "./removeCollection.js";
+import { remove } from "./remove.js";
+import { update } from "./update.js";
 async function safeOpen(path) {
     try {
         await access(path, constants.F_OK);
@@ -16,11 +22,12 @@ async function safeOpen(path) {
         return await open(path, "w+");
     }
 }
-export class BinManager {
+export class BinManager extends ActionsBase {
     path;
     fd = null;
     meta;
     options;
+    _inited = false;
     /**
      * Constructs a new BinManager instance.
      * @param path - File path.
@@ -29,12 +36,12 @@ export class BinManager {
      * not a positive number.
      */
     constructor(path, options) {
+        super();
         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),
@@ -43,23 +50,14 @@ export class BinManager {
             ...options
         };
         if (!this.options.preferredSize || this.options.preferredSize <= 0)
-            throw new Error("Preferred size not provided");
+            throw new Error("Preferred size not provided correctly");
     }
-    async open() {
+    async init() {
         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;
         }
@@ -67,15 +65,19 @@ export class BinManager {
     [Symbol.asyncDispose]() {
         return this.close();
     }
-    async write(collection, data) {
-        if (!this.fd)
-            throw new Error("File not open");
-        await writeLogic(this, collection, data);
+    async getCollections() {
+        return this.meta.collections.map(c => c.name);
+    }
+    async issetCollection(collection) {
+        return this.meta.collections.map(c => c.name).includes(collection);
     }
-    async read(collection) {
+    async ensureCollection(collection) {
         if (!this.fd)
             throw new Error("File not open");
-        return await readLogic(this, collection);
+        if (this.meta.collections.find(c => c.name === collection))
+            return false;
+        await ensureCollection(this, collection, 0, false);
+        return true;
     }
     async optimize() {
         if (!this.fd)
@@ -86,5 +88,39 @@ export class BinManager {
         if (!this.fd)
             throw new Error("File not open");
         await removeCollection(this, collection);
+        return true;
+    }
+    async add(config) {
+        await this.ensureCollection(config.collection);
+        await addId(config, this, false);
+        await add(this, config);
+        return config.data;
+    }
+    async find(config) {
+        await this.ensureCollection(config.collection);
+        const data = await find(this, config);
+        return findUtil(config, data, [""]);
+    }
+    async findOne(config) {
+        await this.ensureCollection(config.collection);
+        return await findOne(this, config);
+    }
+    async update(config) {
+        await this.ensureCollection(config.collection);
+        return await update(this, config, false);
+    }
+    async updateOne(config) {
+        await this.ensureCollection(config.collection);
+        const data = await update(this, config, true);
+        return data[0] ?? null;
+    }
+    async remove(config) {
+        await this.ensureCollection(config.collection);
+        return await remove(this, config, false);
+    }
+    async removeOne(config) {
+        await this.ensureCollection(config.collection);
+        const data = await remove(this, config, true);
+        return data[0] ?? null;
     }
 }

package/dist/bin/optimize.js

@@ -1,6 +1,6 @@
 import { unlink } from "fs/promises";
 import { saveHeaderAndPayload } from "./head.js";
-import { HEADER_SIZE } from "./static.js";
+import { HEADER_SIZE, INT_SIZE } from "./static.js";
 import { readData, roundUpCapacity, writeData } from "./utils.js";
 import { _log } from "../log.js";
 export async function optimize(cmp) {
@@ -19,15 +19,15 @@ export async function optimize(cmp) {
     await unlink(cmp.path);
     await new Promise(resolve => setTimeout(resolve, 100));
     await _log(5, "Re-opening database file for optimization");
-    await cmp.open();
+    await cmp.init();
     let offset = roundUpCapacity(cmp.meta, cmp.meta.payloadLength + HEADER_SIZE) + cmp.meta.blockSize;
+    const lengthBuffer = Buffer.alloc(INT_SIZE);
     for (const [collection, data] of allData) {
         await _log(6, "Writing optimized collection:", collection);
-        const len = roundUpCapacity(cmp.meta, data.length + 4);
-        const buf = Buffer.alloc(4);
-        buf.writeInt32LE(data.length, 0);
-        await writeData(cmp.fd, offset, buf, 4);
-        await writeData(cmp.fd, offset + 4, data, len);
+        const len = roundUpCapacity(cmp.meta, data.length + INT_SIZE);
+        lengthBuffer.writeInt32LE(data.length, 0);
+        await writeData(cmp.fd, offset, lengthBuffer, INT_SIZE);
+        await writeData(cmp.fd, offset + INT_SIZE, data, len);
         cmp.meta.collections.push({
             name: collection,
             offset,

package/dist/bin/remove.d.ts

@@ -0,0 +1,4 @@
+import { DataInternal } from "@wxn0brp/db-core/types/data";
+import { VQueryT } from "@wxn0brp/db-core/types/query";
+import { BinManager } from "./index.js";
+export declare function remove(cmp: BinManager, config: VQueryT.Remove, one: boolean): Promise<DataInternal[]>;

package/dist/bin/remove.js

@@ -0,0 +1,33 @@
+import { matchObj } from "@wxn0brp/db-core/utils/process";
+import { _log } from "../log.js";
+import { findCollection } from "./data.js";
+import { INT_SIZE } from "./static.js";
+import { readCollectionEof, readData, writeData } from "./utils.js";
+export async function remove(cmp, config, one) {
+    await _log(2, "Removing from collection:", config.collection);
+    const collection = findCollection(cmp, config.collection);
+    let cursor = collection.offset + INT_SIZE;
+    const collectionEOF = await readCollectionEof(cmp.fd, collection.offset);
+    if (collectionEOF === 0)
+        return [];
+    const removed = [];
+    const endOffset = collection.offset + INT_SIZE + collectionEOF;
+    while (cursor < endOffset) {
+        const dataLength = (await readData(cmp.fd, cursor, INT_SIZE)).readUInt32LE(0);
+        cursor += INT_SIZE;
+        const dataOffset = cursor;
+        const data = await readData(cmp.fd, cursor, dataLength);
+        cursor += dataLength;
+        // if removed
+        if (new Uint8Array(data).every(byte => byte === 0))
+            continue;
+        const obj = await cmp.options.format.decode(data, config.collection);
+        if (!matchObj(config, obj))
+            continue;
+        await writeData(cmp.fd, dataOffset, Buffer.alloc(dataLength).fill(0), dataLength);
+        removed.push(obj);
+        if (one)
+            break;
+    }
+    return removed;
+}

package/dist/bin/{rm.js → removeCollection.js}

@@ -18,8 +18,7 @@ export async function removeCollection(cmp, collection) {
         offset: collectionMeta.offset,
         capacity: collectionMeta.capacity
     });
-    if (options.overwriteRemovedCollection) {
+    if (options.overwriteRemovedCollection)
         await writeData(fd, collectionMeta.offset, Buffer.alloc(collectionMeta.capacity), collectionMeta.capacity);
-    }
     await saveHeaderAndPayload(cmp);
 }

package/dist/bin/static.d.ts

@@ -1,2 +1,3 @@
 export declare const HEADER_SIZE = 64;
-export declare const VERSION = 1;
+export declare const VERSION = 2;
+export declare const INT_SIZE = 4;

package/dist/bin/static.js

@@ -1,2 +1,3 @@
 export const HEADER_SIZE = 64;
-export const VERSION = 1;
+export const VERSION = 2;
+export const INT_SIZE = 4;

package/dist/bin/update.d.ts

@@ -0,0 +1,4 @@
+import { DataInternal } from "@wxn0brp/db-core/types/data";
+import { VQueryT } from "@wxn0brp/db-core/types/query";
+import { BinManager } from "./index.js";
+export declare function update(cmp: BinManager, config: VQueryT.Update, one: boolean): Promise<DataInternal[]>;

package/dist/bin/update.js

@@ -0,0 +1,85 @@
+import { matchObj, updateObj } from "@wxn0brp/db-core/utils/process";
+import { _log } from "../log.js";
+import { findCollection } from "./data.js";
+import { saveHeaderAndPayload } from "./head.js";
+import { INT_SIZE } from "./static.js";
+import { readCollectionEof, readData, roundUpCapacity, writeData } from "./utils.js";
+export async function update(cmp, config, one) {
+    await _log(2, "Updating in collection:", config.collection);
+    if (typeof config.updater === "object" && Object.keys(config.updater).length === 0)
+        return [];
+    const collection = findCollection(cmp, config.collection);
+    const collectionEOF = await readCollectionEof(cmp.fd, collection.offset);
+    if (collectionEOF === 0)
+        return [];
+    const updated = [];
+    let cursor = collection.offset + INT_SIZE;
+    const fileEnd = cmp.meta.fileSize;
+    let fileEndCursor = fileEnd + INT_SIZE;
+    let newLen = 0;
+    let isUpdated = false;
+    async function writeRecord(data, length, lengthBuff) {
+        await writeData(cmp.fd, fileEndCursor, lengthBuff, INT_SIZE);
+        fileEndCursor += INT_SIZE;
+        await writeData(cmp.fd, fileEndCursor, data, length);
+        fileEndCursor += length;
+        newLen += INT_SIZE + length;
+    }
+    const endOffset = collection.offset + INT_SIZE + collectionEOF;
+    const lengthBuff = Buffer.alloc(INT_SIZE);
+    while (cursor < endOffset) {
+        const dataLengthBuffer = await readData(cmp.fd, cursor, INT_SIZE);
+        const dataLength = dataLengthBuffer.readUInt32LE(0);
+        cursor += INT_SIZE;
+        const data = await readData(cmp.fd, cursor, dataLength);
+        cursor += dataLength;
+        // if removed
+        if (new Uint8Array(data).every(byte => byte === 0))
+            continue;
+        if (one && isUpdated) {
+            await writeRecord(data, dataLength, dataLengthBuffer);
+            continue;
+        }
+        const obj = await cmp.options.format.decode(data, config.collection);
+        const match = matchObj(config, obj);
+        if (!match) {
+            await writeRecord(data, dataLength, dataLengthBuffer);
+            continue;
+        }
+        const updatedObj = updateObj(config, obj);
+        const encoded = Buffer.from(await cmp.options.format.encode(updatedObj, config.collection));
+        const encodedLen = encoded.length;
+        lengthBuff.writeUInt32LE(encodedLen, 0);
+        await writeRecord(encoded, encodedLen, lengthBuff);
+        isUpdated = true;
+        updated.push(updatedObj);
+    }
+    if (newLen <= collectionEOF) {
+        const chunkSize = 2048;
+        const tmpBuffer = Buffer.alloc(chunkSize);
+        const loopCount = Math.floor((newLen + INT_SIZE) / chunkSize);
+        for (let i = 0; i < loopCount; i++) {
+            const readDataOffset = cmp.meta.fileSize + i * chunkSize;
+            const writeDataOffset = collection.offset + i * chunkSize;
+            await cmp.fd.read(tmpBuffer, 0, chunkSize, readDataOffset);
+            await cmp.fd.write(tmpBuffer, 0, chunkSize, writeDataOffset);
+        }
+        const lastChunkSize = (newLen + INT_SIZE) % chunkSize;
+        if (lastChunkSize) {
+            const readDataOffset = cmp.meta.fileSize + loopCount * chunkSize;
+            const writeDataOffset = collection.offset + loopCount * chunkSize;
+            await cmp.fd.read(tmpBuffer, 0, lastChunkSize, readDataOffset);
+            await cmp.fd.write(tmpBuffer, 0, lastChunkSize, writeDataOffset);
+        }
+    }
+    else {
+        cmp.meta.freeList.push({ capacity: collection.capacity, offset: collection.offset });
+        collection.offset = cmp.meta.fileSize;
+        collection.capacity = roundUpCapacity(cmp.meta, newLen);
+        cmp.meta.fileSize += collection.capacity;
+        await saveHeaderAndPayload(cmp);
+        lengthBuff.writeUInt32LE(newLen, 0);
+        await writeData(cmp.fd, collection.offset, lengthBuff, INT_SIZE);
+    }
+    return updated;
+}

package/dist/bin/utils.d.ts

@@ -6,3 +6,4 @@ export declare function readData(fd: FileHandle, offset: number, length: number)
 export declare function optimizeFreeList(blocks: Block[]): Block[];
 export declare function detectCollisions(result: FileMeta, start: number, size: number, skip?: string[]): boolean;
 export declare function pushToFreeList(result: FileMeta, offset: number, len: number): void;
+export declare function readCollectionEof(fd: FileHandle, offset: number): Promise<number>;

package/dist/bin/utils.js

@@ -1,4 +1,5 @@
 import { _log } from "../log.js";
+import { INT_SIZE } from "./static.js";
 export function roundUpCapacity(result, size) {
     return Math.ceil(size / result.blockSize) * result.blockSize;
 }
@@ -70,3 +71,8 @@ export function pushToFreeList(result, offset, len) {
     });
     result.freeList = optimizeFreeList(result.freeList);
 }
+export async function readCollectionEof(fd, offset) {
+    const buf = Buffer.alloc(INT_SIZE);
+    await fd.read(buf, 0, INT_SIZE, offset);
+    return buf.readUInt32LE(0);
+}

package/dist/index.d.ts

@@ -1,13 +1,10 @@
 import { ValtheraClass } from "@wxn0brp/db-core";
-import { BinFileAction } from "./actions.js";
 import { BinManager, Options } from "./bin/index.js";
-export * from "./actions.js";
 export * from "./bin/index.js";
 export declare function createBinValthera(path: string, opts?: Partial<Options>, init?: boolean): Promise<{
     db: ValtheraClass;
-    actions: BinFileAction;
     mgr: BinManager;
 }>;
 export declare const DYNAMIC: {
-    bin(path: string, opts?: Partial<Options>): Promise<BinFileAction>;
+    bin(path: string, opts?: Partial<Options>): Promise<BinManager>;
 };

package/dist/index.js

@@ -1,25 +1,20 @@
 import { ValtheraClass } from "@wxn0brp/db-core";
-import { BinFileAction } from "./actions.js";
 import { BinManager } from "./bin/index.js";
-export * from "./actions.js";
 export * from "./bin/index.js";
 export async function createBinValthera(path, opts = {}, init = true) {
     const mgr = new BinManager(path, opts);
-    const actions = new BinFileAction(mgr);
-    const db = new ValtheraClass({ dbAction: actions });
+    const db = new ValtheraClass({ dbAction: mgr });
     if (init)
-        await actions.init();
+        await mgr.init();
     return {
         db,
-        actions,
         mgr,
     };
 }
 export const DYNAMIC = {
     async bin(path, opts = {}) {
         const mgr = new BinManager(path, opts);
-        const actions = new BinFileAction(mgr);
-        await actions.init();
-        return actions;
+        await mgr.init();
+        return mgr;
     }
 };

package/dist/log.js

@@ -3,7 +3,7 @@ export async function _log(level, ...data) {
     const logLevel = parseInt(process.env.VDB_BIN_LOG_LEVEL || '0', 10);
     if (logLevel < level)
         return;
-    let line = new Error().stack.split('\n')[3].trim();
+    let line = new Error().stack.split('\n')[2].trim();
     let path = line.slice(line.indexOf("(")).replace(dir, "").replace("(", "").replace(")", "");
     const at = line.slice(3, line.indexOf("(") - 1);
     if (path.length < 2)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/db-storage-bin",
-  "version": "0.100.2",
+  "version": "0.110.0-alpha.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",
@@ -19,7 +19,7 @@
   ],
   "devDependencies": {
     "@types/bun": "*",
-    "@wxn0brp/db-core": "^0.10.3",
+    "@wxn0brp/db-core": "^0.11.0-alpha.4",
     "tsc-alias": "^1",
     "typescript": "^6"
   },
@@ -27,7 +27,7 @@
     "@msgpack/msgpack": "^3.1.3"
   },
   "peerDependencies": {
-    "@wxn0brp/db-core": "^0.10.3"
+    "@wxn0brp/db-core": "^0.11.0-alpha.4"
   },
   "files": [
     "dist"

package/dist/actions.d.ts

@@ -1,32 +0,0 @@
-import { CustomActionsBase } from "@wxn0brp/db-core/base/custom";
-import { DbOpts } from "@wxn0brp/db-core/types/options";
-import { BinManager } from "./bin/index.js";
-export declare class BinFileAction extends CustomActionsBase {
-    private mgr;
-    folder: string;
-    options: DbOpts;
-    /**
-     * 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: string): Promise<boolean>;
-    /**
-     * Check if a collection exists.
-     */
-    issetCollection(collection: string): Promise<boolean>;
-    /**
-     * Removes a database collection from the file system.
-     */
-    removeCollection(collection: string): Promise<boolean>;
-}

package/dist/actions.js

@@ -1,51 +0,0 @@
-import { CustomFileCpu } from "@wxn0brp/db-core";
-import { CustomActionsBase } from "@wxn0brp/db-core/base/custom";
-export class BinFileAction extends CustomActionsBase {
-    mgr;
-    folder;
-    options;
-    /**
-     * 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(collection))
-            return false;
-        await this.mgr.write(collection, []);
-        return true;
-    }
-    /**
-     * Check if a collection exists.
-     */
-    async issetCollection(collection) {
-        const collections = await this.getCollections();
-        return collections.includes(collection);
-    }
-    /**
-     * Removes a database collection from the file system.
-     */
-    async removeCollection(collection) {
-        await this.mgr.removeCollection(collection);
-        return true;
-    }
-}

package/dist/crc32.d.ts

@@ -1,6 +0,0 @@
-import { FileHandle } from "fs/promises";
-export declare function crc32(buf: Uint8Array | string, seed?: number): number;
-export declare function getFileCrc(fd: FileHandle, short?: boolean): Promise<{
-    storedCrc: number;
-    computedCrc: number;
-}>;

package/dist/crc32.js

@@ -1,36 +0,0 @@
-import { HEADER_SIZE } from "./bin/static.js";
-const CRC32_TABLE = new Uint32Array(256);
-for (let i = 0; i < 256; i++) {
-    let crc = i;
-    for (let j = 0; j < 8; j++) {
-        crc = (crc & 1) ? (0xEDB88320 ^ (crc >>> 1)) : (crc >>> 1);
-    }
-    CRC32_TABLE[i] = crc >>> 0;
-}
-export function crc32(buf, seed = 0xFFFFFFFF) {
-    if (typeof buf === "string") {
-        buf = new TextEncoder().encode(buf);
-    }
-    let crc = seed ^ 0xFFFFFFFF;
-    for (let i = 0; i < buf.length; i++) {
-        const byte = buf[i];
-        crc = (crc >>> 8) ^ CRC32_TABLE[(crc ^ byte) & 0xFF];
-    }
-    return (crc ^ 0xFFFFFFFF) >>> 0;
-}
-export async function getFileCrc(fd, short = false) {
-    const { size } = await fd.stat();
-    if (size < HEADER_SIZE)
-        return { storedCrc: 0, computedCrc: 0 };
-    const buffer = Buffer.alloc(size);
-    await fd.read(buffer, 0, size, 0);
-    const storedCrc = buffer.readUInt32LE(16);
-    if (short && storedCrc === 0)
-        return { storedCrc: 0, computedCrc: 0 };
-    buffer.fill(0, 16, 20);
-    const computedCrc = crc32(buffer);
-    return {
-        storedCrc,
-        computedCrc
-    };
-}